|
1 /* |
|
2 * Copyright (c) 2010 Ixonos Plc. |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of the "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - Initial contribution |
|
11 * |
|
12 * Contributors: |
|
13 * Ixonos Plc |
|
14 * |
|
15 * Description: |
|
16 * |
|
17 */ |
|
18 |
|
19 |
|
20 // INCLUDE FILES |
|
21 |
|
22 // System includes |
|
23 #include <aknviewappui.h> |
|
24 #include <avkon.hrh> |
|
25 #include <manualvideoeditor.rsg> |
|
26 #include <aknappui.h> |
|
27 #include <akntitle.h> |
|
28 #include <caknfilenamepromptdialog.h> |
|
29 #include <aknnotewrappers.h> |
|
30 #include <aknlists.h> |
|
31 #include <aknquerydialog.h> |
|
32 #include <pathinfo.h> |
|
33 #include <eikmenub.h> |
|
34 |
|
35 #include <sendui.h> |
|
36 #include <caknfileselectiondialog.h> |
|
37 #include <stringloader.h> |
|
38 #include <eikprogi.h> |
|
39 #include <mgfetch.h> |
|
40 #include <aknnavilabel.h> |
|
41 #include <aknnavide.h> |
|
42 #include <aknselectionlist.h> |
|
43 #include <MdaAudioSampleEditor.h> |
|
44 #include <bautils.h> |
|
45 #include <sysutil.h> |
|
46 #include <aknwaitdialog.h> |
|
47 #include <utf.h> |
|
48 #include <akncolourselectiongrid.h> |
|
49 //#include <akncontext.h> |
|
50 #include <MGXFileManagerFactory.h> |
|
51 #include <CMGXFileManager.h> |
|
52 #include <audiopreference.h> |
|
53 #include <senduiconsts.h> |
|
54 #include <mmsconst.h> |
|
55 #include <CMessagedata.h> |
|
56 #include <e32property.h> |
|
57 #include <e32math.h> |
|
58 |
|
59 #include <VedVideoClipInfo.h> |
|
60 |
|
61 // User includes |
|
62 #include "veiapp.h" |
|
63 #include "veicutaudioview.h" |
|
64 #include "VeiEditVideoView.h" |
|
65 #include "VeiEditVideoContainer.h" |
|
66 #include "manualvideoeditor.hrh" |
|
67 #include "veieditvideolabelnavi.h" |
|
68 #include "veicutvideoview.h" |
|
69 #include "veiappui.h" |
|
70 #include "VideoEditorCommon.h" |
|
71 #include "VideoEditorUtils.h" |
|
72 #include "VeiTimeLabelNavi.h" |
|
73 #include "veiaddqueue.h" |
|
74 #include "veitempmaker.h" |
|
75 #include "videoeditorcommon.h" |
|
76 #include "VeiImageClipGenerator.h" |
|
77 #include "VeiTitleClipGenerator.h" |
|
78 #include "VeiTextDisplay.h" |
|
79 #include "VeiPopup.h" |
|
80 #include "VeiVideoEditorSettings.h" |
|
81 #include "VeiMGFetchVerifier.h" |
|
82 #include "VeiErrorUi.h" |
|
83 |
|
84 |
|
85 const TInt KTitleScreenMaxTextLength = 100; //2048; |
|
86 |
|
87 |
|
88 void CleanupRestoreOrientation( TAny* object ) |
|
89 { |
|
90 LOG( KVideoEditorLogFile, "CleanupRestoreOrientation: in" ); |
|
91 |
|
92 CVeiEditVideoView* me = static_cast < CVeiEditVideoView* > ( object ); |
|
93 me->RestoreOrientation(); |
|
94 |
|
95 LOG( KVideoEditorLogFile, "CleanupRestoreOrientation: Out" ); |
|
96 } |
|
97 |
|
98 CVeiEditVideoView* CVeiEditVideoView::NewL( CVeiCutVideoView& aCutView, |
|
99 CVeiCutAudioView& aCutAudioView, |
|
100 CSendUi& aSendAppUi ) |
|
101 { |
|
102 CVeiEditVideoView* self = CVeiEditVideoView::NewLC( aCutView, aCutAudioView, aSendAppUi ); |
|
103 CleanupStack::Pop( self ); |
|
104 return self; |
|
105 } |
|
106 |
|
107 CVeiEditVideoView* CVeiEditVideoView::NewLC( CVeiCutVideoView& aCutView, |
|
108 CVeiCutAudioView& aCutAudioView, |
|
109 CSendUi& aSendAppUi ) |
|
110 { |
|
111 CVeiEditVideoView* self = new ( ELeave ) CVeiEditVideoView( aCutView, aCutAudioView, aSendAppUi ); |
|
112 CleanupStack::PushL( self ); |
|
113 self->ConstructL(); |
|
114 return self; |
|
115 } |
|
116 |
|
117 CVeiEditVideoView::CVeiEditVideoView( CVeiCutVideoView& aCutView, |
|
118 CVeiCutAudioView& aCutAudioView, |
|
119 CSendUi& aSendAppUi ) |
|
120 : iCutView( aCutView ), |
|
121 iCutAudioView( aCutAudioView ), |
|
122 iSendAppUi( aSendAppUi ), |
|
123 iOriginalAudioStartPoint( -1 ), |
|
124 iOriginalAudioDuration( -1 ), |
|
125 iMemoryCardChecked(EFalse), |
|
126 iOriginalOrientation( CAknAppUiBase::EAppUiOrientationAutomatic ) |
|
127 { |
|
128 iOriginalVideoClipIndex = - 1; |
|
129 iMovieSavedFlag = ETrue; |
|
130 SetNewTempFileNeeded( EFalse ); |
|
131 iMovieFirstAddFlag = ETrue; |
|
132 iWaitMode = ENotWaiting; |
|
133 } |
|
134 |
|
135 void CVeiEditVideoView::ConstructL() |
|
136 { |
|
137 LOG( KVideoEditorLogFile, "CVeiEditVideoView::ConstructL: in" ); |
|
138 |
|
139 BaseConstructL( R_VEI_EDIT_VIDEO_VIEW ); |
|
140 |
|
141 CEikStatusPane* sp = StatusPane(); |
|
142 iNaviPane = ( CAknNavigationControlContainer* ) sp->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ); |
|
143 |
|
144 /** General navilabel(mms state, movie size, movie time). |
|
145 Is visible always except when in moving state */ |
|
146 iEditLabel = CreateEditNaviLabelL(); |
|
147 |
|
148 |
|
149 /** Navilabel when previewing video in small preview */ |
|
150 iPreviewLabel = CreatePreviewNaviLabelL(); |
|
151 |
|
152 /** Navipane updating timer when editor is on small preview - mode */ |
|
153 iPreviewUpdatePeriodic = CPeriodic::NewL( CActive::EPriorityLow ); |
|
154 |
|
155 /* volume bars are showed when volume is changed in small preview */ |
|
156 // iVolumeHider = CPeriodic::NewL( CActive::EPriorityLow ); |
|
157 |
|
158 iVolumeNavi = iNaviPane->CreateVolumeIndicatorL( |
|
159 R_AVKON_NAVI_PANE_VOLUME_INDICATOR ); |
|
160 |
|
161 /** Navilabel when audio or video clip is in moving state */ |
|
162 iMoveLabel = CreateMoveNaviLabelL(); |
|
163 |
|
164 iTempMaker = CVeiTempMaker::NewL(); |
|
165 |
|
166 iErrorUI = CVeiErrorUI::NewL( *iCoeEnv ); |
|
167 |
|
168 iMovie = CVedMovie::NewL( NULL ); |
|
169 iMovie->RegisterMovieObserverL( this ); |
|
170 |
|
171 /** All media files are added to video/audio tracks through mediaqueue */ |
|
172 iMediaQueue = CVeiAddQueue::NewL( *this, * iMovie, * this ); |
|
173 |
|
174 iOriginalAudioDuration = TTimeIntervalMicroSeconds( - 1 ); |
|
175 /* Create recorder with max priority. */ |
|
176 iRecorder = CMdaAudioRecorderUtility::NewL( *this, NULL, EMdaPriorityMax, |
|
177 TMdaPriorityPreference( KAudioPrefVideoRecording ) |
|
178 /*EMdaPriorityPreferenceQuality*/ ); |
|
179 iAudioRecordPeriodic = CPeriodic::NewL( CActive::EPriorityStandard ); |
|
180 |
|
181 /** Popup menus for video editor */ |
|
182 iPopup = CVeiPopup::NewL( *this ); |
|
183 |
|
184 LOG( KVideoEditorLogFile, "CVeiEditVideoView::ConstructL: out" ); |
|
185 } |
|
186 |
|
187 TUid CVeiEditVideoView::Id()const |
|
188 { |
|
189 return TUid::Uid( EVeiEditVideoView ); |
|
190 } |
|
191 |
|
192 CAknNavigationDecorator* CVeiEditVideoView::CreateMoveNaviLabelL() |
|
193 { |
|
194 CAknNaviLabel* movelabel = new( ELeave )CAknNaviLabel; |
|
195 movelabel->SetNaviLabelType( CAknNaviLabel::ENavigationLabel ); |
|
196 |
|
197 CleanupStack::PushL( movelabel ); |
|
198 |
|
199 CAknNavigationDecorator* decoratedFolder = CAknNavigationDecorator::NewL( |
|
200 iNaviPane, movelabel, CAknNavigationDecorator::ENotSpecified ); |
|
201 |
|
202 CleanupStack::Pop( movelabel ); |
|
203 |
|
204 CleanupStack::PushL( decoratedFolder ); |
|
205 decoratedFolder->SetContainerWindowL( *iNaviPane ); |
|
206 CleanupStack::Pop( decoratedFolder ); |
|
207 decoratedFolder->MakeScrollButtonVisible( ETrue ); |
|
208 |
|
209 return decoratedFolder; |
|
210 } |
|
211 |
|
212 CAknNavigationDecorator* CVeiEditVideoView::CreatePreviewNaviLabelL() |
|
213 { |
|
214 CVeiTimeLabelNavi* timelabelnavi = CVeiTimeLabelNavi::NewLC(); |
|
215 CAknNavigationDecorator* decoratedFolder = CAknNavigationDecorator::NewL( |
|
216 iNaviPane, timelabelnavi, CAknNavigationDecorator::ENotSpecified ); |
|
217 CleanupStack::Pop( timelabelnavi ); |
|
218 |
|
219 CleanupStack::PushL( decoratedFolder ); |
|
220 decoratedFolder->SetContainerWindowL( *iNaviPane ); |
|
221 CleanupStack::Pop( decoratedFolder ); |
|
222 decoratedFolder->MakeScrollButtonVisible( EFalse ); |
|
223 |
|
224 return decoratedFolder; |
|
225 } |
|
226 |
|
227 /** |
|
228 * Default navilabel. Shows MMS,Size and Time information. |
|
229 */ |
|
230 CAknNavigationDecorator* CVeiEditVideoView::CreateEditNaviLabelL() |
|
231 { |
|
232 CVeiEditVideoLabelNavi* editvideolabelnavi = CVeiEditVideoLabelNavi::NewLC(); |
|
233 |
|
234 editvideolabelnavi->SetState( CVeiEditVideoLabelNavi::EStateInitializing ); |
|
235 |
|
236 CAknNavigationDecorator* navidecorator = CAknNavigationDecorator::NewL( |
|
237 iNaviPane, editvideolabelnavi, CAknNavigationDecorator::ENotSpecified ); |
|
238 |
|
239 CleanupStack::Pop( editvideolabelnavi ); |
|
240 |
|
241 CleanupStack::PushL( navidecorator ); |
|
242 navidecorator->SetContainerWindowL( *iNaviPane ); |
|
243 CleanupStack::Pop( navidecorator ); |
|
244 navidecorator->MakeScrollButtonVisible( EFalse ); |
|
245 |
|
246 return navidecorator; |
|
247 } |
|
248 |
|
249 CVeiEditVideoView::~CVeiEditVideoView() |
|
250 { |
|
251 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: In" ); |
|
252 |
|
253 if ( iProgressNote ) |
|
254 { |
|
255 delete iProgressNote; |
|
256 iProgressNote = NULL; |
|
257 } |
|
258 |
|
259 if ( iPopup ) |
|
260 { |
|
261 delete iPopup; |
|
262 iPopup = NULL; |
|
263 } |
|
264 |
|
265 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iContainer" ); |
|
266 if ( iContainer ) |
|
267 { |
|
268 AppUi()->RemoveFromStack( iContainer ); |
|
269 delete iContainer; |
|
270 iContainer = NULL; |
|
271 } |
|
272 |
|
273 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iMediaQueue" ); |
|
274 if ( iMediaQueue ) |
|
275 { |
|
276 delete iMediaQueue; |
|
277 } |
|
278 |
|
279 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iMovie" ); |
|
280 if ( iMovie ) |
|
281 { |
|
282 iMovie->Reset(); |
|
283 //if application is closed from cut video view, observer is not |
|
284 //registered. |
|
285 if ( ( EProcessingMovieForCutting != iWaitMode ) && |
|
286 ( ECuttingAudio != iWaitMode ) ) |
|
287 { |
|
288 iMovie->UnregisterMovieObserver( this ); |
|
289 } |
|
290 delete iMovie; |
|
291 iMovie = NULL; |
|
292 } |
|
293 |
|
294 if ( iAudioRecordPeriodic ) |
|
295 { |
|
296 iAudioRecordPeriodic->Cancel(); |
|
297 delete iAudioRecordPeriodic; |
|
298 } |
|
299 |
|
300 if ( iPreviewUpdatePeriodic ) |
|
301 { |
|
302 iPreviewUpdatePeriodic->Cancel(); |
|
303 delete iPreviewUpdatePeriodic; |
|
304 } |
|
305 |
|
306 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iTempFile" ); |
|
307 if ( iTempFile ) |
|
308 { |
|
309 TInt err = iEikonEnv->FsSession().Delete( *iTempFile ); |
|
310 if ( err ) |
|
311 { |
|
312 // what to do when error occurs in destructor??? |
|
313 } |
|
314 delete iTempFile; |
|
315 iTempFile = NULL; |
|
316 } |
|
317 |
|
318 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iSaveToFileName" ); |
|
319 |
|
320 if ( iSaveToFileName ) |
|
321 { |
|
322 delete iSaveToFileName; |
|
323 iSaveToFileName = NULL; |
|
324 } |
|
325 |
|
326 if ( iTempRecordedAudio ) |
|
327 { |
|
328 TInt err = iEikonEnv->FsSession().Delete( *iTempRecordedAudio ); |
|
329 if ( err ) |
|
330 { |
|
331 // what to do when error occurs in destructor??? |
|
332 } |
|
333 delete iTempRecordedAudio; |
|
334 iTempRecordedAudio = NULL; |
|
335 } |
|
336 |
|
337 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iTempMaker" ); |
|
338 |
|
339 if ( iTempMaker ) |
|
340 { |
|
341 delete iTempMaker; |
|
342 iTempMaker = NULL; |
|
343 } |
|
344 |
|
345 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iErrorUI" ); |
|
346 if ( iErrorUI ) |
|
347 { |
|
348 delete iErrorUI; |
|
349 iErrorUI = NULL; |
|
350 } |
|
351 |
|
352 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iAudioClipInfo" ); |
|
353 delete iAudioClipInfo; |
|
354 |
|
355 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iEditLabel" ); |
|
356 delete iEditLabel; |
|
357 |
|
358 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iMoveLabel" ); |
|
359 delete iMoveLabel; |
|
360 |
|
361 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iPreviewLabel" ); |
|
362 delete iPreviewLabel; |
|
363 |
|
364 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iRecorder" ); |
|
365 if ( iRecorder ) |
|
366 { |
|
367 delete iRecorder; |
|
368 iRecorder = NULL; |
|
369 } |
|
370 |
|
371 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iVolumeHider" ); |
|
372 if ( iVolumeHider ) |
|
373 { |
|
374 iVolumeHider->Cancel(); |
|
375 delete iVolumeHider; |
|
376 } |
|
377 |
|
378 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: iVolumeNavi" ); |
|
379 delete iVolumeNavi; |
|
380 |
|
381 delete iCallBack; |
|
382 |
|
383 LOG( KVideoEditorLogFile, "CVeiEditVideoView::~CVeiEditVideoView: Out" ); |
|
384 } |
|
385 |
|
386 void CVeiEditVideoView::DialogDismissedL( TInt aButtonId ) |
|
387 { |
|
388 LOGFMT2( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: In, aButtonId:%d, iWaitMode:%d", aButtonId, iWaitMode ); |
|
389 |
|
390 IsEnoughFreeSpaceToSaveL(); |
|
391 |
|
392 if ( aButtonId != EAknSoftkeyDone ) |
|
393 { |
|
394 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: In, 2" ); |
|
395 CMdaAudioRecorderUtility::TState rState; |
|
396 rState = CMdaAudioClipUtility::ENotReady; |
|
397 |
|
398 if ( iRecorder ) |
|
399 { |
|
400 rState = iRecorder->State(); |
|
401 } |
|
402 |
|
403 if (( EOpeningAudioInfo == iWaitMode ) || ( CMdaAudioClipUtility::EOpen == rState )) |
|
404 { |
|
405 delete iAudioClipInfo; |
|
406 iAudioClipInfo = NULL; |
|
407 iWaitMode = EProcessingError; |
|
408 iMovie->CancelProcessing(); |
|
409 } |
|
410 else |
|
411 { |
|
412 iWaitMode = EProcessingError; |
|
413 iMovie->CancelProcessing(); |
|
414 } |
|
415 } |
|
416 else if ( EProcessingMovieSend == iWaitMode ) |
|
417 { |
|
418 //SendMovieL(); |
|
419 if ( !iCallBack ) |
|
420 { |
|
421 TCallBack cb( CVeiEditVideoView::AsyncBackSend, this ); |
|
422 iCallBack = new ( ELeave ) CAsyncCallBack( cb, CActive::EPriorityStandard ); |
|
423 } |
|
424 iCallBack->CallBack(); |
|
425 } |
|
426 else if ( EProcessingMovieTrimMms == iWaitMode ) |
|
427 { |
|
428 SetNewTempFileNeeded( EFalse ); |
|
429 |
|
430 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 3, EProcessingMovieTrimMms" ); |
|
431 |
|
432 RFs& fs = iEikonEnv->FsSession(); |
|
433 TEntry entry; |
|
434 User::LeaveIfError( fs.Entry( *iTempFile, entry )); |
|
435 TInt tempFileSize = entry.iSize / 1024; |
|
436 TInt maxMmsSize = STATIC_CAST( CVeiEditVideoLabelNavi*, iEditLabel->DecoratedControl() )->GetMaxMmsSize(); |
|
437 |
|
438 LOGFMT2( KVideoEditorLogFile, |
|
439 "CVeiEditVideoView::DialogDismissedL: 4, tempFileSize:%d, maxMmsSize:%d", tempFileSize, maxMmsSize ); |
|
440 |
|
441 if ( iMovie->IsMovieMMSCompatible()) |
|
442 { |
|
443 if ( tempFileSize <= maxMmsSize ) |
|
444 { |
|
445 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 5, MMS SIZE OK -- SEND" ); |
|
446 iWaitMode = EProcessingMovieSend; |
|
447 iGivenSendCommand = KSenduiMtmMmsUid; // MMS |
|
448 |
|
449 //SendMovieL(); |
|
450 if ( !iCallBack ) |
|
451 { |
|
452 TCallBack cb( CVeiEditVideoView::AsyncBackSend, this ); |
|
453 iCallBack = new( ELeave )CAsyncCallBack( cb, CActive::EPriorityStandard ); |
|
454 } |
|
455 iCallBack->CallBack(); |
|
456 } |
|
457 else |
|
458 { |
|
459 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 6, MMS SIZE FAILED - to TRIMM" ); |
|
460 TBuf8 < 255 > conv8Filename; |
|
461 CnvUtfConverter::ConvertFromUnicodeToUtf8( conv8Filename, *iTempFile ); |
|
462 iMovie->UnregisterMovieObserver( iContainer ); |
|
463 iMovie->UnregisterMovieObserver( this ); |
|
464 |
|
465 AppUi()->ActivateLocalViewL( TUid::Uid( EVeiTrimForMmsView ), TUid::Uid(0), conv8Filename ); |
|
466 } |
|
467 } |
|
468 else |
|
469 { |
|
470 // if movie is not mms capable, trimming it does not help, instead its quality should be set |
|
471 // trimming is made when other compatibility issues are fullfilled |
|
472 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 7, MMS Compatible FAILED - to TRIMM" ); |
|
473 TBuf8 < KMaxFileName > conv8Filename; |
|
474 CnvUtfConverter::ConvertFromUnicodeToUtf8( conv8Filename, *iTempFile ); |
|
475 |
|
476 iMovie->UnregisterMovieObserver( iContainer ); |
|
477 iMovie->UnregisterMovieObserver( this ); |
|
478 |
|
479 AppUi()->ActivateLocalViewL( TUid::Uid( EVeiTrimForMmsView ), TUid::Uid( 0 ), conv8Filename ); |
|
480 } |
|
481 iMovie->SetQuality( iBackupSaveQuality ); |
|
482 return ; |
|
483 } |
|
484 else if (( EProcessingMovieSave == iWaitMode ) || |
|
485 ( EProcessingMovieSaveThenQuit == iWaitMode )) |
|
486 { |
|
487 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 8, EProcessingMovieSave|EProcessingMovieSaveThenQuit" ); |
|
488 RFs& fs = iEikonEnv->FsSession(); |
|
489 |
|
490 CFileMan* fileman = CFileMan::NewL( fs ); |
|
491 CleanupStack::PushL( fileman ); |
|
492 |
|
493 TInt moveErr( KErrNone ); |
|
494 |
|
495 if ( iTempFile->Left( 1 ) == iSaveToFileName->Left( 1 )) |
|
496 { |
|
497 moveErr = fileman->Rename( *iTempFile, * iSaveToFileName ); |
|
498 LOGFMT2( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 9, rename %S to %S", iTempFile, iSaveToFileName ); |
|
499 } |
|
500 else |
|
501 { |
|
502 moveErr = fileman->Move( *iTempFile, * iSaveToFileName ); |
|
503 LOGFMT2( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 10, moved %S to %S", iTempFile, iSaveToFileName ); |
|
504 } |
|
505 CleanupStack::PopAndDestroy( fileman ); |
|
506 |
|
507 delete iTempFile; |
|
508 iTempFile = NULL; |
|
509 |
|
510 if ( moveErr ) |
|
511 { |
|
512 ShowGlobalErrorNote( moveErr ); |
|
513 UpdateEditNaviLabel(); |
|
514 iWaitMode = ENotWaiting; |
|
515 return ; |
|
516 } |
|
517 |
|
518 iMovieSavedFlag = ETrue; |
|
519 |
|
520 if ( EProcessingMovieSaveThenQuit == iWaitMode ) |
|
521 { |
|
522 iMovie->Reset(); |
|
523 iMovieFirstAddFlag = ETrue; // True for the next edit process. |
|
524 } |
|
525 |
|
526 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 11" ); |
|
527 UpdateMediaGalleryL(); |
|
528 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 12, media gallery updated" ); |
|
529 |
|
530 if ( EProcessingMovieSaveThenQuit == iWaitMode ) |
|
531 { |
|
532 if ( !iCallBack ) |
|
533 { |
|
534 TCallBack cb( CVeiEditVideoView::AsyncBackSaveThenExitL, this ); |
|
535 iCallBack = new( ELeave )CAsyncCallBack( cb, CActive::EPriorityStandard ); |
|
536 |
|
537 } |
|
538 iCallBack->CallBack(); |
|
539 } |
|
540 |
|
541 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL Out" ); |
|
542 return ; |
|
543 } |
|
544 else if ( EProcessingMoviePreview == iWaitMode && ( iTempFile != NULL )) |
|
545 { |
|
546 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModePreview ); |
|
547 iContainer->PlayVideoFileL( *iTempFile, iFullScreenSelected ); |
|
548 } |
|
549 else |
|
550 { |
|
551 if ( EProcessingError == iWaitMode ) |
|
552 { |
|
553 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 13" ); |
|
554 if ( iTempFile ) |
|
555 { |
|
556 RFs& fs = iEikonEnv->FsSession(); |
|
557 |
|
558 fs.Delete( *iTempFile ); |
|
559 delete iTempFile; |
|
560 iTempFile = NULL; |
|
561 SetNewTempFileNeeded( ETrue ); |
|
562 } |
|
563 |
|
564 iWaitMode = ENotWaiting; |
|
565 ShowGlobalErrorNote( iErrorNmb ); |
|
566 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 14" ); |
|
567 UpdateEditNaviLabel(); |
|
568 } |
|
569 |
|
570 if ( EProcessingAudioError == iWaitMode ) |
|
571 { |
|
572 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 15" ); |
|
573 ShowErrorNote( R_VEI_ERRORNOTE_AUDIO_INSERTING_FAILED ); |
|
574 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: 16" ); |
|
575 UpdateEditNaviLabel(); |
|
576 iWaitMode = ENotWaiting; |
|
577 } |
|
578 |
|
579 if ( iChangedFromMMCToPhoneMemory ) |
|
580 { |
|
581 HBufC* noteText = StringLoader::LoadLC( R_VED_MMC_NOT_INSERTED, |
|
582 iEikonEnv ); |
|
583 CAknInformationNote* informationNote = new( ELeave ) |
|
584 CAknInformationNote( ETrue ); |
|
585 informationNote->ExecuteLD( *noteText ); |
|
586 |
|
587 CleanupStack::PopAndDestroy( noteText ); |
|
588 } |
|
589 } |
|
590 if ( EProcessingMovieSend != iWaitMode ) |
|
591 { |
|
592 iWaitMode = ENotWaiting; |
|
593 } |
|
594 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DialogDismissedL: Out" ); |
|
595 } |
|
596 |
|
597 |
|
598 TInt CVeiEditVideoView::AsyncBackSend( TAny* aThis ) |
|
599 { |
|
600 LOG( KVideoEditorLogFile, "CVeiEditVideoView::AsyncBackSend" ); |
|
601 |
|
602 // In the asynchronous version, trap the rest of the functions |
|
603 // to make sure that the caller's TRequestStatus is always |
|
604 // completed, also in case of failures. |
|
605 CVeiEditVideoView* view = static_cast < CVeiEditVideoView* > ( aThis ); |
|
606 TInt err = KErrNone; |
|
607 TRAP( err, view->SendMovieL()); |
|
608 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::AsyncBackSend 1, err:%d", err ); |
|
609 |
|
610 view->iWaitMode = ENotWaiting; |
|
611 User::LeaveIfError( err ); |
|
612 return KErrNone; |
|
613 } |
|
614 |
|
615 TInt CVeiEditVideoView::AsyncBackSaveThenExitL( TAny* aThis ) |
|
616 { |
|
617 LOG( KVideoEditorLogFile, "CVeiEditVideoView::AsyncBackSaveThenExitL In" ); |
|
618 |
|
619 // In the asynchronous version, trap the rest of the functions |
|
620 // to make sure that the caller's TRequestStatus is always |
|
621 // completed, also in case of failures. |
|
622 |
|
623 CVeiEditVideoView* view = static_cast < CVeiEditVideoView* > ( aThis ); |
|
624 |
|
625 view->AppUi()->HandleCommandL( EAknCmdExit ); |
|
626 LOG( KVideoEditorLogFile, "CVeiEditVideoView::AsyncBackSaveThenExitL 1" ); |
|
627 return KErrNone; |
|
628 } |
|
629 |
|
630 void CVeiEditVideoView::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* |
|
631 aMenuPane ) |
|
632 { |
|
633 if ( !iContainer || !iMovie ) |
|
634 { |
|
635 return ; |
|
636 } |
|
637 if ( aResourceId == R_VEI_EDIT_VIDEO_VIEW_MENU && CVeiEditVideoContainer |
|
638 ::EModeMixingAudio == iContainer->SelectionMode()) |
|
639 { |
|
640 // Dim all the items and replace the with |
|
641 // R_VEI_EDIT_VIDEO_VIEW_AUDIO_MIXING_MENU |
|
642 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewInsert, ETrue ); |
|
643 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditVideo, ETrue ); |
|
644 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditAudio, ETrue ); |
|
645 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditText, ETrue ); |
|
646 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditImage, ETrue ); |
|
647 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewMovie, ETrue ); |
|
648 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewSettings, ETrue ); |
|
649 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditStartTransition, ETrue ); |
|
650 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditMiddleTransition, ETrue ); |
|
651 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditEndTransition, ETrue ); |
|
652 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewHelp, ETrue ); |
|
653 aMenuPane->SetItemDimmed( EEikCmdExit, ETrue ); |
|
654 |
|
655 aMenuPane->AddMenuItemsL( R_VEI_EDIT_VIDEO_VIEW_AUDIO_MIXING_MENU ); |
|
656 |
|
657 return ; |
|
658 } |
|
659 |
|
660 if (( aResourceId == R_VEI_EDIT_VIDEO_VIEW_EDIT_VIDEO_MENU ) || |
|
661 ( aResourceId == R_VEI_EDIT_VIDEO_VIEW_EDIT_VIDEO_SUBMENU )) |
|
662 { |
|
663 // @ : if muted, remove AdjustVolume, if video has no audio, remove AdjustVolume |
|
664 //if (!iMovie->VideoClipEditedHasAudio(iContainer->CurrentIndex())) |
|
665 if ( !( iMovie->VideoClipInfo( iContainer->CurrentIndex()))->HasAudio()) |
|
666 { |
|
667 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoAdjustVolume ); |
|
668 } |
|
669 |
|
670 if ( iMovie->VideoClipCount() < 2 ) |
|
671 { |
|
672 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewEditVideoMove ); |
|
673 } |
|
674 |
|
675 if ( iMovie->VideoClipIsMuteable( iContainer->CurrentIndex()) == EFalse |
|
676 ) |
|
677 { |
|
678 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewEditVideoMute ); |
|
679 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewEditVideoUnmute ); |
|
680 } |
|
681 else if ( iMovie->VideoClipIsMuted( iContainer->CurrentIndex())) |
|
682 { |
|
683 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewEditVideoMute ); |
|
684 } |
|
685 else |
|
686 { |
|
687 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewEditVideoUnmute ); |
|
688 } |
|
689 // remove "cut" if video duration < 1 sec. because engine/codec(s) do not handle them wholly at the moment |
|
690 TTimeIntervalMicroSeconds duration = iMovie->VideoClipInfo( |
|
691 iContainer->CurrentIndex())->Duration(); |
|
692 if ( duration.Int64() < KMinCutVideoLength ) |
|
693 { |
|
694 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewEditVideoCutting ); |
|
695 } |
|
696 } |
|
697 |
|
698 if ( aResourceId == R_VEI_EDIT_VIDEO_VIEW_MOVIE_SUBMENU ) |
|
699 { |
|
700 if ( STATIC_CAST( CVeiEditVideoLabelNavi* , |
|
701 iEditLabel->DecoratedControl())->IsMMSAvailable()) |
|
702 { |
|
703 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewTrimForMms, ETrue ); |
|
704 } |
|
705 |
|
706 /*TInt tempint; |
|
707 if (aMenuPane->MenuItemExists(EVeiCmdEditVideoMixAudio, tempint)) |
|
708 { |
|
709 if ((iMovie->VideoClipCount() > 0 && |
|
710 (iMovie->VideoClipEditedHasAudio(0) && |
|
711 iMovie->VideoClipEditedHasAudio(iMovie->VideoClipCount() - 1))) |
|
712 && iMovie->AudioClipCount() > 0)*/ |
|
713 if ( MixingConditionsOk()) |
|
714 { |
|
715 aMenuPane->SetItemDimmed( EVeiCmdEditVideoMixAudio, EFalse ); |
|
716 } |
|
717 else |
|
718 { |
|
719 aMenuPane->SetItemDimmed( EVeiCmdEditVideoMixAudio, ETrue ); |
|
720 } |
|
721 //} |
|
722 } |
|
723 |
|
724 if ( aResourceId == R_VEI_EDIT_VIDEO_VIEW_MENU ) |
|
725 { |
|
726 if ( iSendKey ) |
|
727 //Display send menu. |
|
728 { |
|
729 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewInsert, ETrue ); |
|
730 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditVideo, ETrue ); |
|
731 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditAudio, ETrue ); |
|
732 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditText, ETrue ); |
|
733 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditImage, ETrue ); |
|
734 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewMovie, ETrue ); |
|
735 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewSettings, ETrue ); |
|
736 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditStartTransition, ETrue ); |
|
737 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditMiddleTransition, ETrue ); |
|
738 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditEndTransition, ETrue ); |
|
739 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewHelp, ETrue ); |
|
740 aMenuPane->SetItemDimmed( EEikCmdExit, ETrue ); |
|
741 |
|
742 ShowAndHandleSendMenuCommandsL(); |
|
743 |
|
744 iSendKey = EFalse; |
|
745 return ; |
|
746 } |
|
747 |
|
748 if ( iMovie->VideoClipCount() == 0 ) |
|
749 { |
|
750 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditVideo, ETrue ); |
|
751 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditText, ETrue ); |
|
752 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditImage, ETrue ); |
|
753 } |
|
754 |
|
755 |
|
756 if ( iMovie->VideoClipCount() == 0 && iMovie->AudioClipCount() == 0 ) |
|
757 { |
|
758 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditStartTransition, ETrue ); |
|
759 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditMiddleTransition, ETrue ); |
|
760 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditEndTransition, ETrue ); |
|
761 |
|
762 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewMovie, ETrue ); |
|
763 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditAudio, ETrue ); |
|
764 return ; |
|
765 } |
|
766 else |
|
767 { |
|
768 TInt index = 0; |
|
769 |
|
770 aMenuPane->ItemAndPos( EVeiCmdEditVideoViewHelp, index ); |
|
771 iSendAppUi.AddSendMenuItemL( *aMenuPane, index, EVeiCmdEditVideoViewSend ); |
|
772 } |
|
773 /* Remove irrelevant "edit" menus. */ |
|
774 |
|
775 if ( iContainer->CursorLocation() != VideoEditor::ECursorOnClip ) |
|
776 { |
|
777 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditText, ETrue ); |
|
778 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditVideo, ETrue ); |
|
779 } |
|
780 /* Checks if title or image */ |
|
781 if (( iContainer->CursorLocation() == VideoEditor::ECursorOnClip ) && |
|
782 ( iMovie->VideoClipCount() > 0 ) && |
|
783 ( iMovie->VideoClipInfo( iContainer->CurrentIndex())->Class() |
|
784 == EVedVideoClipClassGenerated |
|
785 )) |
|
786 { |
|
787 /* Now refine the menu dimming to specific generators. */ |
|
788 TUid generatorUid = iMovie->VideoClipInfo( |
|
789 iContainer->CurrentIndex())->Generator()->Uid(); |
|
790 |
|
791 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditVideo, ETrue ); |
|
792 if ( generatorUid == KUidImageClipGenerator ) |
|
793 { |
|
794 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditText, ETrue ); |
|
795 } |
|
796 else |
|
797 { |
|
798 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditImage, ETrue ) |
|
799 ; |
|
800 } |
|
801 } |
|
802 else |
|
803 { |
|
804 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditImage, ETrue ); |
|
805 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditText, ETrue ); |
|
806 } |
|
807 |
|
808 |
|
809 if ( iContainer->CurrentClipIsFile()) |
|
810 { |
|
811 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditText, ETrue ); |
|
812 } |
|
813 else |
|
814 { |
|
815 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditVideo, ETrue ); |
|
816 } |
|
817 |
|
818 if ( iContainer->CursorLocation() != VideoEditor::ECursorOnTransition ) |
|
819 { |
|
820 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewEditStartTransition ) |
|
821 ; |
|
822 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewEditEndTransition ); |
|
823 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewEditMiddleTransition |
|
824 ); |
|
825 } |
|
826 if (( iContainer->CursorLocation() != VideoEditor::ECursorOnAudio ) || |
|
827 ( iMovie->AudioClipCount() == 0 )) |
|
828 { |
|
829 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditAudio, ETrue ); |
|
830 } |
|
831 |
|
832 /* Remove irrelevant transition effect menus. */ |
|
833 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnAudio ) |
|
834 { |
|
835 aMenuPane->SetItemDimmed( EVeiCmdEditVideoViewEditText, ETrue ); |
|
836 } |
|
837 |
|
838 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnTransition ) |
|
839 { |
|
840 if ( iContainer->CurrentIndex() == 0 ) |
|
841 { |
|
842 aMenuPane->DeleteMenuItem( |
|
843 EVeiCmdEditVideoViewEditEndTransition ); |
|
844 aMenuPane->DeleteMenuItem( |
|
845 EVeiCmdEditVideoViewEditMiddleTransition ); |
|
846 } |
|
847 else if ( iContainer->CurrentIndex() < iMovie->VideoClipCount()) |
|
848 { |
|
849 aMenuPane->DeleteMenuItem( |
|
850 EVeiCmdEditVideoViewEditStartTransition ); |
|
851 aMenuPane->DeleteMenuItem( |
|
852 EVeiCmdEditVideoViewEditEndTransition ); |
|
853 } |
|
854 else |
|
855 { |
|
856 aMenuPane->DeleteMenuItem( |
|
857 EVeiCmdEditVideoViewEditStartTransition ); |
|
858 aMenuPane->DeleteMenuItem( |
|
859 EVeiCmdEditVideoViewEditMiddleTransition ); |
|
860 } |
|
861 } |
|
862 } |
|
863 |
|
864 if ( aResourceId == R_VEI_EDIT_VIDEO_VIEW_EDIT_START_TRANSITION_SUBMENU ) |
|
865 { |
|
866 switch ( iMovie->StartTransitionEffect()) |
|
867 { |
|
868 case EVedStartTransitionEffectNone: |
|
869 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewTransitionNone ); |
|
870 break; |
|
871 case EVedStartTransitionEffectFadeFromBlack: |
|
872 aMenuPane->DeleteMenuItem( |
|
873 EVeiCmdEditVideoViewTransitionFadeFromBlack ); |
|
874 break; |
|
875 case EVedStartTransitionEffectFadeFromWhite: |
|
876 aMenuPane->DeleteMenuItem( |
|
877 EVeiCmdEditVideoViewTransitionFadeFromWhite ); |
|
878 break; |
|
879 default: |
|
880 break; |
|
881 } |
|
882 } |
|
883 |
|
884 if ( aResourceId == R_VEI_EDIT_VIDEO_VIEW_EDIT_END_TRANSITION_SUBMENU ) |
|
885 { |
|
886 switch ( iMovie->EndTransitionEffect()) |
|
887 { |
|
888 case EVedEndTransitionEffectNone: |
|
889 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewTransitionNone ); |
|
890 break; |
|
891 case EVedEndTransitionEffectFadeToBlack: |
|
892 aMenuPane->DeleteMenuItem( |
|
893 EVeiCmdEditVideoViewTransitionFadeToBlack ); |
|
894 break; |
|
895 case EVedEndTransitionEffectFadeToWhite: |
|
896 aMenuPane->DeleteMenuItem( |
|
897 EVeiCmdEditVideoViewTransitionFadeToWhite ); |
|
898 break; |
|
899 default: |
|
900 break; |
|
901 } |
|
902 } |
|
903 |
|
904 if ( aResourceId == R_VEI_EDIT_VIDEO_VIEW_EDIT_MIDDLE_TRANSITION_SUBMENU ) |
|
905 { |
|
906 TInt currentindex = iContainer->CurrentIndex() - 1; |
|
907 switch ( iMovie->MiddleTransitionEffect( currentindex )) |
|
908 { |
|
909 case EVedMiddleTransitionEffectNone: |
|
910 aMenuPane->DeleteMenuItem( EVeiCmdEditVideoViewTransitionNone ); |
|
911 break; |
|
912 case EVedMiddleTransitionEffectDipToBlack: |
|
913 aMenuPane->DeleteMenuItem( |
|
914 EVeiCmdEditVideoViewTransitionDipToBlack ); |
|
915 break; |
|
916 case EVedMiddleTransitionEffectDipToWhite: |
|
917 aMenuPane->DeleteMenuItem( |
|
918 EVeiCmdEditVideoViewTransitionDipToWhite ); |
|
919 break; |
|
920 case EVedMiddleTransitionEffectCrossfade: |
|
921 aMenuPane->DeleteMenuItem( |
|
922 EVeiCmdEditVideoViewTransitionCrossfade ); |
|
923 break; |
|
924 case EVedMiddleTransitionEffectWipeLeftToRight: |
|
925 aMenuPane->DeleteMenuItem( |
|
926 EVeiCmdEditVideoViewTransitionWipeFromLeft ); |
|
927 break; |
|
928 case EVedMiddleTransitionEffectWipeRightToLeft: |
|
929 aMenuPane->DeleteMenuItem( |
|
930 EVeiCmdEditVideoViewTransitionWipeFromRight ); |
|
931 break; |
|
932 case EVedMiddleTransitionEffectWipeTopToBottom: |
|
933 aMenuPane->DeleteMenuItem( |
|
934 EVeiCmdEditVideoViewTransitionWipeFromTop ); |
|
935 break; |
|
936 case EVedMiddleTransitionEffectWipeBottomToTop: |
|
937 aMenuPane->DeleteMenuItem( |
|
938 EVeiCmdEditVideoViewTransitionWipeFromBottom ); |
|
939 break; |
|
940 default: |
|
941 break; |
|
942 } |
|
943 } |
|
944 } |
|
945 |
|
946 void CVeiEditVideoView::HandleCommandL( TInt aCommand ) |
|
947 { |
|
948 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::HandleCommandL( %d ): In", aCommand ); |
|
949 |
|
950 // At the startup HandleCommandL may get called before iContainer |
|
951 // has been constructed. |
|
952 if ( !iContainer ) |
|
953 { |
|
954 LOG( KVideoEditorLogFile, "\tiContainer == NULL" ); |
|
955 AppUi()->HandleCommandL( aCommand ); |
|
956 return ; |
|
957 } |
|
958 |
|
959 TInt index; |
|
960 switch ( aCommand ) |
|
961 { |
|
962 /* Cursor is on transition and up/key key is pressed*/ |
|
963 case EVeiCmdEditVideoViewTransitionKeyUp: |
|
964 { |
|
965 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionKeyUp" ); |
|
966 BrowseStartTransition( ETrue ); |
|
967 break; |
|
968 } |
|
969 case EVeiCmdEditVideoViewTransitionKeyDown: |
|
970 { |
|
971 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionKeyDown" ); |
|
972 BrowseStartTransition( EFalse ); |
|
973 break; |
|
974 } |
|
975 case EVeiCmdSendMovie: |
|
976 { |
|
977 LOG( KVideoEditorLogFile, "\tEVeiCmdSendMovie" ); |
|
978 if (( iMovie->VideoClipCount() == 0 ) && |
|
979 ( iMovie->AudioClipCount() == 0 )) |
|
980 { |
|
981 iSendKey = EFalse; |
|
982 } |
|
983 else |
|
984 { |
|
985 MenuBar()->TryDisplayMenuBarL(); |
|
986 } |
|
987 break; |
|
988 } |
|
989 case EAknSoftkeyDone: |
|
990 { |
|
991 LOG( KVideoEditorLogFile, "\tEAknSoftkeyDone" ); |
|
992 |
|
993 /*if (CVeiEditVideoContainer::EModeMixingAudio == iContainer->SelectionMode()) |
|
994 { |
|
995 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); |
|
996 Cba()->DrawDeferred(); |
|
997 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
998 //iContainer->ArrowsControl(); |
|
999 break; |
|
1000 } |
|
1001 */ |
|
1002 |
|
1003 if ( CVeiEditVideoContainer::EModeMixingAudio == iContainer->SelectionMode()) |
|
1004 |
|
1005 { |
|
1006 |
|
1007 MixAudio(); |
|
1008 |
|
1009 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); |
|
1010 Cba()->DrawDeferred(); |
|
1011 |
|
1012 VideoEditor::TCursorLocation cursorLocation = iContainer->CursorLocation(); |
|
1013 if (( cursorLocation == VideoEditor::ECursorOnClip ) && |
|
1014 ( iContainer->SelectionMode() == CVeiEditVideoContainer::EModeSlowMotion )) |
|
1015 |
|
1016 { |
|
1017 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
1018 iContainer->ArrowsControl(); |
|
1019 } |
|
1020 else |
|
1021 { |
|
1022 iOriginalAudioClipIndex = - 1; |
|
1023 iOriginalVideoClipIndex = - 1; |
|
1024 iOriginalAudioStartPoint = TTimeIntervalMicroSeconds( -1 ); |
|
1025 iOriginalAudioDuration = TTimeIntervalMicroSeconds( -1 ); |
|
1026 |
|
1027 |
|
1028 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
1029 } |
|
1030 SetEditorState( EEdit ); |
|
1031 UpdateEditNaviLabel(); |
|
1032 |
|
1033 // Setting the cursor location resets the image in the video display box |
|
1034 iContainer->SetCursorLocation( cursorLocation ); |
|
1035 } |
|
1036 break; |
|
1037 } |
|
1038 |
|
1039 case EAknSoftkeyOk: |
|
1040 { |
|
1041 LOG( KVideoEditorLogFile, "\tEAknSoftkeyOk" ); |
|
1042 |
|
1043 if ( CVeiEditVideoContainer::EModeAdjustVolume == iContainer->SelectionMode()) |
|
1044 |
|
1045 { |
|
1046 AdjustVolumeL(); |
|
1047 SetEditorState( EEdit ); |
|
1048 } |
|
1049 |
|
1050 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); |
|
1051 Cba()->DrawDeferred(); |
|
1052 |
|
1053 if (( iContainer->CursorLocation() == VideoEditor::ECursorOnClip ) && |
|
1054 ( iContainer->SelectionMode() == CVeiEditVideoContainer::EModeSlowMotion )) |
|
1055 |
|
1056 { |
|
1057 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
1058 iContainer->ArrowsControl(); |
|
1059 } |
|
1060 else |
|
1061 { |
|
1062 iOriginalAudioClipIndex = - 1; |
|
1063 iOriginalVideoClipIndex = - 1; |
|
1064 iOriginalAudioStartPoint = TTimeIntervalMicroSeconds( -1 ); |
|
1065 iOriginalAudioDuration = TTimeIntervalMicroSeconds( -1 ); |
|
1066 |
|
1067 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
1068 } |
|
1069 UpdateEditNaviLabel(); |
|
1070 break; |
|
1071 } |
|
1072 case EAknSoftkeyCancel: |
|
1073 case EVeiCmdEditVideoMixAudioCancel: |
|
1074 { |
|
1075 LOG( KVideoEditorLogFile, "\tEAknSoftkeyCancel||EVeiCmdEditVideoMixAudioCancel" ); |
|
1076 |
|
1077 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); |
|
1078 Cba()->DrawDeferred(); |
|
1079 |
|
1080 SetEditorState( EEdit ); |
|
1081 |
|
1082 if ( CVeiEditVideoContainer::EModeMixingAudio == iContainer->SelectionMode() || |
|
1083 CVeiEditVideoContainer::EModeAdjustVolume == iContainer->SelectionMode()) |
|
1084 { |
|
1085 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
1086 // Setting the cursor location resets the image in the video display box |
|
1087 iContainer->SetCursorLocation( iContainer->CursorLocation()); |
|
1088 break; |
|
1089 } |
|
1090 |
|
1091 if (( iContainer->CursorLocation() == VideoEditor::ECursorOnClip ) && |
|
1092 ( iContainer->SelectionMode() == CVeiEditVideoContainer::EModeSlowMotion )) |
|
1093 { |
|
1094 iMovie->VideoClipSetSpeed( iContainer->CurrentIndex(), iOriginalVideoSpeed ); |
|
1095 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
1096 |
|
1097 iContainer->ArrowsControl(); |
|
1098 } |
|
1099 else |
|
1100 { |
|
1101 if ( iContainer->CursorLocation() == VideoEditor |
|
1102 ::ECursorOnAudio ) |
|
1103 { |
|
1104 if ( iOriginalAudioStartPoint >= TTimeIntervalMicroSeconds( 0 )) |
|
1105 { |
|
1106 iMovie->AudioClipSetStartTime( iContainer->CurrentIndex(), iOriginalAudioStartPoint ); |
|
1107 iOriginalAudioStartPoint = TTimeIntervalMicroSeconds( -1 ); |
|
1108 iMovie->AudioClipSetCutOutTime( iContainer->CurrentIndex(), iOriginalAudioDuration ); |
|
1109 iOriginalAudioDuration = TTimeIntervalMicroSeconds( -1 ); |
|
1110 } |
|
1111 else |
|
1112 { |
|
1113 index = iContainer->CurrentIndex(); |
|
1114 |
|
1115 iContainer->SetCurrentIndex( iOriginalAudioClipIndex ); |
|
1116 iOriginalAudioClipIndex = - 1; |
|
1117 iOriginalAudioDuration = TTimeIntervalMicroSeconds( -1 ); |
|
1118 |
|
1119 iMovie->RemoveAudioClip( index ); |
|
1120 } |
|
1121 } |
|
1122 else |
|
1123 { |
|
1124 if ( iContainer->SelectionMode() != CVeiEditVideoContainer::EModeDuration ) |
|
1125 { |
|
1126 iMovie->VideoClipSetIndex( iContainer->CurrentIndex(), iOriginalVideoClipIndex ); |
|
1127 iContainer->SetVideoCursorPosition( iOriginalVideoClipIndex ); |
|
1128 iOriginalVideoClipIndex = - 1; |
|
1129 } |
|
1130 else |
|
1131 { |
|
1132 CVedVideoClipInfo* info = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
1133 if ( info->Class() == EVedVideoClipClassGenerated ) |
|
1134 { |
|
1135 if ( info->Generator()->Uid() == KUidTitleClipGenerator ) |
|
1136 { |
|
1137 CVeiTitleClipGenerator* generator = |
|
1138 STATIC_CAST( CVeiTitleClipGenerator* , info->Generator()); |
|
1139 generator->SetDuration( TTimeIntervalMicroSeconds( |
|
1140 iOriginalVideoCutOutTime.Int64() - |
|
1141 iOriginalVideoCutInTime.Int64())); |
|
1142 } |
|
1143 else if ( info->Generator()->Uid() == KUidImageClipGenerator ) |
|
1144 { |
|
1145 CVeiImageClipGenerator* generator = |
|
1146 STATIC_CAST( CVeiImageClipGenerator* , info->Generator()); |
|
1147 generator->SetDuration( TTimeIntervalMicroSeconds( |
|
1148 iOriginalVideoCutOutTime.Int64() - |
|
1149 iOriginalVideoCutInTime.Int64())); |
|
1150 } |
|
1151 } |
|
1152 } |
|
1153 } |
|
1154 } |
|
1155 |
|
1156 if ( iContainer->SelectionMode() == CVeiEditVideoContainer |
|
1157 ::EModePreview ) |
|
1158 { |
|
1159 iContainer->SetBlackScreen( EFalse ); |
|
1160 iContainer->SetRect( AppUi()->ClientRect()); |
|
1161 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
1162 iContainer->ArrowsControl(); |
|
1163 } |
|
1164 else |
|
1165 { |
|
1166 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
1167 UpdateEditNaviLabel(); |
|
1168 } |
|
1169 break; |
|
1170 } |
|
1171 case EVeiCmdEditVideoViewSend: |
|
1172 { |
|
1173 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewSend" ); |
|
1174 ShowAndHandleSendMenuCommandsL(); |
|
1175 break; |
|
1176 } |
|
1177 |
|
1178 case EVeiCmdEditVideoViewPreviewLarge: |
|
1179 case EVeiCmdEditVideoViewPreviewSmall: |
|
1180 { |
|
1181 LOG( KVideoEditorLogFile, |
|
1182 "\tEVeiCmdEditVideoViewPreviewLarge||EVeiCmdEditVideoViewPreviewSmall" ); |
|
1183 |
|
1184 if ( CVeiEditVideoContainer::EModeMixingAudio == iContainer->SelectionMode()) |
|
1185 { |
|
1186 MixAudio(); |
|
1187 } |
|
1188 |
|
1189 if ( IsEnoughFreeSpaceToSaveL()) |
|
1190 { |
|
1191 if ( aCommand == EVeiCmdEditVideoViewPreviewLarge ) |
|
1192 { |
|
1193 iFullScreenSelected = ETrue; |
|
1194 } |
|
1195 else |
|
1196 { |
|
1197 iFullScreenSelected = EFalse; |
|
1198 } |
|
1199 iWaitMode = EProcessingMoviePreview; |
|
1200 StartTempFileProcessingL(); |
|
1201 } |
|
1202 break; |
|
1203 } |
|
1204 |
|
1205 /** |
|
1206 * Trim for MMS |
|
1207 */ |
|
1208 case EVeiCmdEditVideoViewTrimForMms: |
|
1209 { |
|
1210 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTrimForMms" ); |
|
1211 if ( IsEnoughFreeSpaceToSaveL()) |
|
1212 { |
|
1213 iWaitMode = EProcessingMovieTrimMms; |
|
1214 StartTempFileProcessingL(); |
|
1215 } |
|
1216 break; |
|
1217 } |
|
1218 /** |
|
1219 * Cut (Audio and Video) |
|
1220 */ |
|
1221 case EVeiCmdEditVideoViewEditVideoCutting: |
|
1222 { |
|
1223 LOG( KVideoEditorLogFile, |
|
1224 "\tEVeiCmdEditVideoViewEditVideoCutting" ); |
|
1225 |
|
1226 if ( IsEnoughFreeSpaceToSaveL()) |
|
1227 { |
|
1228 // Cut video |
|
1229 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnClip ) |
|
1230 { |
|
1231 __ASSERT_ALWAYS( iMovie->VideoClipCount() > 0, |
|
1232 User::Panic( _L( "VideoEditor" ), 34 )); |
|
1233 |
|
1234 iCutVideoIndex = iContainer->CurrentIndex(); |
|
1235 iWaitMode = EProcessingMovieForCutting; |
|
1236 iOriginalCutInTime = iMovie->VideoClipCutInTime( iCutVideoIndex ); |
|
1237 iOriginalCutOutTime = iMovie->VideoClipCutOutTime( iCutVideoIndex ); |
|
1238 |
|
1239 iMovie->UnregisterMovieObserver( iContainer ); |
|
1240 iMovie->UnregisterMovieObserver( this ); |
|
1241 |
|
1242 AppUi()->DeactivateActiveViewL(); |
|
1243 |
|
1244 // set file name & clip |
|
1245 iCutView.SetVideoClipAndIndex( *iMovie, iCutVideoIndex ) |
|
1246 ; |
|
1247 |
|
1248 // activate cut view |
|
1249 AppUi()->ActivateLocalViewL( iCutView.Id()); |
|
1250 } |
|
1251 else if ( iContainer->CursorLocation() == VideoEditor::ECursorOnAudio ) |
|
1252 // Cut audio |
|
1253 { |
|
1254 __ASSERT_ALWAYS( iMovie->AudioClipCount() > 0, |
|
1255 User::Panic( _L( "VideoEditor" ), 34 )); |
|
1256 |
|
1257 iCutAudioIndex = iContainer->CurrentIndex(); |
|
1258 iWaitMode = ECuttingAudio; |
|
1259 iOriginalAudioCutInTime = iMovie->AudioClipCutInTime( iCutAudioIndex ); |
|
1260 iOriginalAudioCutOutTime = iMovie->AudioClipCutOutTime( iCutAudioIndex ); |
|
1261 |
|
1262 iMovie->UnregisterMovieObserver( iContainer ); |
|
1263 iMovie->UnregisterMovieObserver( this ); |
|
1264 |
|
1265 AppUi()->DeactivateActiveViewL(); |
|
1266 |
|
1267 // set file name & clip |
|
1268 iCutAudioView.SetVideoClipAndIndex( *iMovie, iCutAudioIndex ); |
|
1269 // activate cut view |
|
1270 AppUi()->ActivateLocalViewL( TUid::Uid( EVeiCutAudioView )); |
|
1271 } |
|
1272 } |
|
1273 break; |
|
1274 } |
|
1275 /** |
|
1276 * Selection (joystick). |
|
1277 */ |
|
1278 case EVeiCmdEditVideoViewContainerShowMenu: |
|
1279 { |
|
1280 LOG( KVideoEditorLogFile, |
|
1281 "\tEVeiCmdEditVideoViewContainerShowMenu" ); |
|
1282 |
|
1283 //preview popup |
|
1284 if ( iEditorState != EEdit ) |
|
1285 { |
|
1286 if ( iEditorState == CVeiEditVideoView::EQuickPreview ) |
|
1287 { |
|
1288 StopNaviPaneUpdateL(); |
|
1289 iContainer->PauseVideoL(); |
|
1290 LOG( KVideoEditorLogFile, |
|
1291 "\tEVeiCmdEditVideoViewContainerShowMenu, setting R_VEI_SOFTKEYS_PREVIEW_PLAY_BACK" ); |
|
1292 Cba()->SetCommandSetL( R_VEI_SOFTKEYS_PREVIEW_PLAY_BACK |
|
1293 ); |
|
1294 Cba()->DrawDeferred(); |
|
1295 } |
|
1296 MenuBar()->SetMenuTitleResourceId( R_VEI_PREVIEW_BAR ); |
|
1297 MenuBar()->TryDisplayMenuBarL(); |
|
1298 MenuBar()->SetMenuTitleResourceId( |
|
1299 R_VEI_MENUBAR_EDIT_VIDEO_VIEW ); |
|
1300 break; |
|
1301 } |
|
1302 switch ( iContainer->CursorLocation()) |
|
1303 { |
|
1304 case VideoEditor::ECursorOnAudio: |
|
1305 { |
|
1306 iPopup->ShowEditAudioPopupList(); |
|
1307 break; |
|
1308 } |
|
1309 case VideoEditor::ECursorOnClip: |
|
1310 { |
|
1311 if ( iMovie->VideoClipInfo( iContainer->CurrentIndex())->Class() == EVedVideoClipClassFile ) |
|
1312 { |
|
1313 iPopup->ShowEditVideoPopupList(); |
|
1314 } |
|
1315 else |
|
1316 { |
|
1317 |
|
1318 TUid generatorUid = iMovie->VideoClipInfo( |
|
1319 iContainer->CurrentIndex())->Generator()->Uid(); |
|
1320 if ( generatorUid == KUidImageClipGenerator ) |
|
1321 // Image |
|
1322 { |
|
1323 iPopup->ShowEditImagePopupList(); |
|
1324 } |
|
1325 else |
|
1326 // Text |
|
1327 { |
|
1328 iPopup->ShowEditTextPopupList(); |
|
1329 } |
|
1330 } |
|
1331 break; |
|
1332 } |
|
1333 /** |
|
1334 * Cursor on video transition. |
|
1335 */ |
|
1336 case VideoEditor::ECursorOnTransition: |
|
1337 { |
|
1338 if ( iContainer->CurrentIndex() == 0 ) |
|
1339 { |
|
1340 iPopup->ShowStartTransitionPopupListL(); |
|
1341 } |
|
1342 else if ( iContainer->CurrentIndex() < iMovie->VideoClipCount()) |
|
1343 { |
|
1344 iPopup->ShowMiddleTransitionPopupListL(); |
|
1345 } |
|
1346 else |
|
1347 { |
|
1348 iPopup->ShowEndTransitionPopupListL(); |
|
1349 } |
|
1350 break; |
|
1351 } |
|
1352 default: |
|
1353 break; |
|
1354 } |
|
1355 break; |
|
1356 } |
|
1357 case EVeiCmdEditVideoViewInsert: |
|
1358 case EVeiCmdEditVideoViewEditVideo: |
|
1359 case EVeiCmdEditVideoViewEditAudio: |
|
1360 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewInsert||EVeiCmdEditVideoViewEditVideo||EVeiCmdEditVideoViewEditAudio" ); |
|
1361 break; |
|
1362 case EVeiCmdEditVideoViewTransitionNone: |
|
1363 { |
|
1364 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionNone" ); |
|
1365 |
|
1366 if ( iContainer->CurrentIndex() == 0 ) |
|
1367 { |
|
1368 iMovie->SetStartTransitionEffect( EVedStartTransitionEffectNone ); |
|
1369 } |
|
1370 else if ( iContainer->CurrentIndex() < iMovie->VideoClipCount()) |
|
1371 { |
|
1372 index = iContainer->CurrentIndex() - 1; |
|
1373 iMovie->SetMiddleTransitionEffect( EVedMiddleTransitionEffectNone, index ); |
|
1374 } |
|
1375 else |
|
1376 { |
|
1377 iMovie->SetEndTransitionEffect( EVedEndTransitionEffectNone ); |
|
1378 } |
|
1379 break; |
|
1380 } |
|
1381 case EVeiCmdEditVideoViewTransitionFadeFromBlack: |
|
1382 { |
|
1383 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionFadeFromBlack" ); |
|
1384 __ASSERT_ALWAYS( iContainer->CurrentIndex() == 0, User::Panic( _L( "VideoEditor" ), 34 )); |
|
1385 iMovie->SetStartTransitionEffect( EVedStartTransitionEffectFadeFromBlack ); |
|
1386 break; |
|
1387 } |
|
1388 case EVeiCmdEditVideoViewTransitionFadeFromWhite: |
|
1389 { |
|
1390 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionFadeFromWhite" ); |
|
1391 __ASSERT_ALWAYS( iContainer->CurrentIndex() == 0, User::Panic( _L( "VideoEditor" ), 34 )); |
|
1392 iMovie->SetStartTransitionEffect( EVedStartTransitionEffectFadeFromWhite ); |
|
1393 break; |
|
1394 } |
|
1395 case EVeiCmdEditVideoViewTransitionDipToBlack: |
|
1396 { |
|
1397 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionDipToBlack" ); |
|
1398 __ASSERT_ALWAYS( iContainer->CurrentIndex() < iMovie->VideoClipCount(), User::Panic( _L( "VideoEditor" ), 34 )); |
|
1399 __ASSERT_ALWAYS( iContainer->CurrentIndex() > 0, User::Panic( _L( "VideoEditor" ), 34 )); |
|
1400 index = iContainer->CurrentIndex() - 1; |
|
1401 iMovie->SetMiddleTransitionEffect( EVedMiddleTransitionEffectDipToBlack, index ); |
|
1402 break; |
|
1403 } |
|
1404 case EVeiCmdEditVideoViewTransitionDipToWhite: |
|
1405 { |
|
1406 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionDipToWhite" ); |
|
1407 __ASSERT_ALWAYS( iContainer->CurrentIndex() < iMovie->VideoClipCount(), User::Panic( _L( "VideoEditor" ), 34 )); |
|
1408 __ASSERT_ALWAYS( iContainer->CurrentIndex() > 0, User::Panic( _L( "VideoEditor" ), 34 )); |
|
1409 index = iContainer->CurrentIndex() - 1; |
|
1410 iMovie->SetMiddleTransitionEffect( EVedMiddleTransitionEffectDipToWhite, index ); |
|
1411 break; |
|
1412 } |
|
1413 case EVeiCmdEditVideoViewTransitionCrossfade: |
|
1414 { |
|
1415 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionCrossfade" ); |
|
1416 __ASSERT_ALWAYS( iContainer->CurrentIndex() < iMovie->VideoClipCount(), User::Panic( _L( "VideoEditor" ), 34 )); |
|
1417 __ASSERT_ALWAYS( iContainer->CurrentIndex() > 0, User::Panic( _L( "VideoEditor" ), 34 )); |
|
1418 index = iContainer->CurrentIndex() - 1; |
|
1419 iMovie->SetMiddleTransitionEffect( EVedMiddleTransitionEffectCrossfade, index ); |
|
1420 break; |
|
1421 } |
|
1422 case EVeiCmdEditVideoViewTransitionWipeFromLeft: |
|
1423 { |
|
1424 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionWipeFromLeft" ); |
|
1425 __ASSERT_ALWAYS( iContainer->CurrentIndex() < iMovie->VideoClipCount(), User::Panic( _L( "VideoEditor" ), 34 )); |
|
1426 __ASSERT_ALWAYS( iContainer->CurrentIndex() > 0, User::Panic( _L( "VideoEditor" ), 34 )); |
|
1427 index = iContainer->CurrentIndex() - 1; |
|
1428 iMovie->SetMiddleTransitionEffect( EVedMiddleTransitionEffectWipeLeftToRight, index ); |
|
1429 break; |
|
1430 } |
|
1431 case EVeiCmdEditVideoViewTransitionWipeFromRight: |
|
1432 { |
|
1433 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionWipeFromRight" ); |
|
1434 __ASSERT_ALWAYS( iContainer->CurrentIndex() < iMovie->VideoClipCount(), User::Panic( _L( "VideoEditor" ), 34 )); |
|
1435 __ASSERT_ALWAYS( iContainer->CurrentIndex() > 0, User::Panic( _L( "VideoEditor" ), 34 )); |
|
1436 index = iContainer->CurrentIndex() - 1; |
|
1437 iMovie->SetMiddleTransitionEffect( EVedMiddleTransitionEffectWipeRightToLeft, index ); |
|
1438 break; |
|
1439 } |
|
1440 case EVeiCmdEditVideoViewTransitionWipeFromTop: |
|
1441 { |
|
1442 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionWipeFromTop" ); |
|
1443 __ASSERT_ALWAYS( iContainer->CurrentIndex() < iMovie->VideoClipCount(), User::Panic( _L( "VideoEditor" ), 34 )); |
|
1444 __ASSERT_ALWAYS( iContainer->CurrentIndex() > 0, User::Panic( _L( "VideoEditor" ), 34 )); |
|
1445 index = iContainer->CurrentIndex() - 1; |
|
1446 iMovie->SetMiddleTransitionEffect( EVedMiddleTransitionEffectWipeTopToBottom, index ); |
|
1447 break; |
|
1448 } |
|
1449 case EVeiCmdEditVideoViewTransitionWipeFromBottom: |
|
1450 { |
|
1451 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionWipeFromBottom" ); |
|
1452 __ASSERT_ALWAYS( iContainer->CurrentIndex() < iMovie->VideoClipCount(), User::Panic( _L( "VideoEditor" ), 34 )); |
|
1453 __ASSERT_ALWAYS( iContainer->CurrentIndex() > 0, User::Panic( _L( "VideoEditor" ), 34 )); |
|
1454 index = iContainer->CurrentIndex() - 1; |
|
1455 iMovie->SetMiddleTransitionEffect( EVedMiddleTransitionEffectWipeBottomToTop, index ); |
|
1456 break; |
|
1457 } |
|
1458 case EVeiCmdEditVideoViewTransitionFadeToBlack: |
|
1459 { |
|
1460 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionFadeToBlack" ); |
|
1461 __ASSERT_ALWAYS( iContainer->CurrentIndex() == iMovie->VideoClipCount(), User::Panic( _L( "VideoEditor" ), 34 )); |
|
1462 iMovie->SetEndTransitionEffect( EVedEndTransitionEffectFadeToBlack ); |
|
1463 break; |
|
1464 } |
|
1465 case EVeiCmdEditVideoViewTransitionFadeToWhite: |
|
1466 { |
|
1467 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewTransitionFadeToWhite" ); |
|
1468 __ASSERT_ALWAYS( iContainer->CurrentIndex() == iMovie->VideoClipCount(), User::Panic( _L( "VideoEditor" ), 34 )); |
|
1469 iMovie->SetEndTransitionEffect( EVedEndTransitionEffectFadeToWhite ); |
|
1470 break; |
|
1471 } |
|
1472 case EVeiCmdEditVideoViewEditStartTransition: |
|
1473 case EVeiCmdEditVideoViewEditMiddleTransition: |
|
1474 case EVeiCmdEditVideoViewEditEndTransition: |
|
1475 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditStartTransition||EVeiCmdEditVideoViewEditMiddleTransition||EVeiCmdEditVideoViewEditEndTransition" ); |
|
1476 break; |
|
1477 case EVeiCmdEditVideoViewSaveTo: |
|
1478 { |
|
1479 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewSaveTo" ); |
|
1480 if ( IsEnoughFreeSpaceToSaveL()) |
|
1481 { |
|
1482 TInt err; |
|
1483 TRAP( err, SaveL( EProcessingMovieSave )); |
|
1484 if ( err != KErrNone ) |
|
1485 { |
|
1486 ShowErrorNote( R_VEI_ERROR_NOTE ); |
|
1487 } |
|
1488 } |
|
1489 break; |
|
1490 } |
|
1491 case EVeiCmdEditVideoMixAudio: |
|
1492 { |
|
1493 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoMixAudio" ); |
|
1494 SetEditorState( EMixAudio ); |
|
1495 break; |
|
1496 } |
|
1497 |
|
1498 case EVeiCmdEditVideoAdjustVolume: |
|
1499 { |
|
1500 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoAdjustVolume" ); |
|
1501 SetEditorState( EAdjustVolume ); |
|
1502 break; |
|
1503 } |
|
1504 |
|
1505 case EVeiCmdEditVideoViewInsertVideo: |
|
1506 { |
|
1507 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewInsertVideo" ); |
|
1508 if ( IsEnoughFreeSpaceToSaveL()) |
|
1509 { |
|
1510 __ASSERT_ALWAYS( iMediaQueue, User::Panic( _L( "CVeiEditVideoView" ), 1 )); |
|
1511 |
|
1512 if ( !iMediaQueue->ShowVideoClipDialogL( iContainer->CursorLocation(), iContainer->CurrentIndex())) |
|
1513 { |
|
1514 return ; |
|
1515 } |
|
1516 } |
|
1517 HandleScreenDeviceChangedL(); |
|
1518 break; |
|
1519 } |
|
1520 case EVeiCmdEditVideoDuplicate: |
|
1521 { |
|
1522 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoDuplicate" ); |
|
1523 if ( IsEnoughFreeSpaceToSaveL()) |
|
1524 { |
|
1525 TEntry fileinfo; |
|
1526 |
|
1527 SetNewTempFileNeeded( ETrue ); |
|
1528 iMovieSavedFlag = EFalse; |
|
1529 |
|
1530 iWaitMode = EDuplicating; |
|
1531 |
|
1532 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnClip ) |
|
1533 { |
|
1534 CVedVideoClipInfo* previousInfo = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
1535 |
|
1536 RFs& fs = iEikonEnv->FsSession(); |
|
1537 fs.Entry( previousInfo->FileName(), fileinfo ); |
|
1538 |
|
1539 if ( IsEnoughFreeSpaceToSaveL( fileinfo.iSize )) |
|
1540 { |
|
1541 iMovie->InsertVideoClipL( previousInfo->FileName(), iContainer->CurrentIndex() + 1 ); |
|
1542 } |
|
1543 } |
|
1544 else |
|
1545 { |
|
1546 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnAudio ) |
|
1547 { |
|
1548 CVedAudioClipInfo* currentInfo = iMovie->AudioClipInfo( iContainer->CurrentIndex()); |
|
1549 TTimeIntervalMicroSeconds currentDuration = iMovie->AudioClipEditedDuration( iContainer->CurrentIndex()); |
|
1550 |
|
1551 TInt currentIndex = iContainer->CurrentIndex(); |
|
1552 |
|
1553 for ( TInt i = iMovie->AudioClipCount() - 1; i > currentIndex; i-- ) |
|
1554 { |
|
1555 TTimeIntervalMicroSeconds oldStartTime = iMovie->AudioClipStartTime( i ); |
|
1556 iMovie->AudioClipSetStartTime( i, TTimeIntervalMicroSeconds( oldStartTime.Int64() + currentDuration.Int64())); |
|
1557 } |
|
1558 |
|
1559 TTimeIntervalMicroSeconds currentAudioClipEndTime = iMovie->AudioClipEndTime( currentIndex ); |
|
1560 TTimeIntervalMicroSeconds currentCutInTime = iMovie->AudioClipCutInTime( currentIndex ); |
|
1561 TTimeIntervalMicroSeconds currentCutOutTime = iMovie->AudioClipCutOutTime( currentIndex ); |
|
1562 iMovie->AddAudioClipL( currentInfo->FileName(), currentAudioClipEndTime, currentCutInTime, currentCutOutTime ); |
|
1563 } |
|
1564 } |
|
1565 } |
|
1566 break; |
|
1567 } |
|
1568 |
|
1569 /* |
|
1570 * Insert TITLE text * |
|
1571 */ |
|
1572 case EVeiCmdEditVideoViewInsertText: |
|
1573 { |
|
1574 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewInsertText" ); |
|
1575 if ( IsEnoughFreeSpaceToSaveL()) |
|
1576 { |
|
1577 iPopup->ShowInsertTextPopupList(); |
|
1578 } |
|
1579 break; |
|
1580 } |
|
1581 |
|
1582 case EVeiCmdEditVideoViewInsertTextTitle: |
|
1583 { |
|
1584 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewInsertTextTitle" ); |
|
1585 |
|
1586 if ( IsEnoughFreeSpaceToSaveL()) |
|
1587 { |
|
1588 StoreOrientation(); |
|
1589 CleanupStack::PushL( TCleanupItem( CleanupRestoreOrientation, this )); |
|
1590 AppUi()->SetOrientationL( CAknAppUiBase::EAppUiOrientationPortrait ); |
|
1591 |
|
1592 TSize res = TSize( iMovie->Resolution()); |
|
1593 |
|
1594 CVeiTitleClipGenerator* generator = CVeiTitleClipGenerator::NewLC( res, |
|
1595 EVeiTitleClipTransitionNone, |
|
1596 EVeiTitleClipHorizontalAlignmentCenter, |
|
1597 EVeiTitleClipVerticalAlignmentCenter ); |
|
1598 |
|
1599 HBufC* descriptiveName = StringLoader::LoadLC( R_VEI_EDIT_VIEW_TITLE_NAME, iEikonEnv ); |
|
1600 generator->SetDescriptiveNameL( *descriptiveName ); |
|
1601 CleanupStack::PopAndDestroy( descriptiveName ); |
|
1602 |
|
1603 generator->SetTransitionAndAlignmentsL( EVeiTitleClipTransitionNone, |
|
1604 EVeiTitleClipHorizontalAlignmentCenter, |
|
1605 EVeiTitleClipVerticalAlignmentCenter ); |
|
1606 |
|
1607 /* Ask for text. */ |
|
1608 HBufC* text = HBufC::NewLC( KTitleScreenMaxTextLength ); |
|
1609 TPtr txtptr( text->Des()); |
|
1610 CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL( txtptr ); |
|
1611 CleanupStack::PushL( textQuery ); |
|
1612 |
|
1613 textQuery->SetMaxLength( KTitleScreenMaxTextLength ); |
|
1614 //textQuery->SetPredictiveTextInputPermitted(ETrue); |
|
1615 CleanupStack::Pop( textQuery ); |
|
1616 |
|
1617 if ( !textQuery->ExecuteLD( R_VEI_EDITVIDEO_TITLESCREEN_TEXT_QUERY )) |
|
1618 { |
|
1619 CleanupStack::PopAndDestroy( text ); |
|
1620 CleanupStack::PopAndDestroy( generator ); |
|
1621 CleanupStack::PopAndDestroy( this ); // restore appui orientation |
|
1622 break; |
|
1623 } |
|
1624 |
|
1625 generator->SetTextL( *text ); |
|
1626 CleanupStack::PopAndDestroy( text ); |
|
1627 |
|
1628 /* Insert generator into the movie. */ |
|
1629 TInt err = 0; |
|
1630 index = ( iContainer->CurrentIndex() == iMovie->VideoClipCount()) ? iMovie->VideoClipCount(): iContainer->CurrentIndex() + 1; |
|
1631 TRAP( err, iMovie->InsertVideoClipL( *generator, ETrue, index )); |
|
1632 |
|
1633 CleanupStack::Pop( generator ); |
|
1634 User::LeaveIfError( err ); |
|
1635 |
|
1636 CleanupStack::PopAndDestroy( this ); // restore appui orientation |
|
1637 } |
|
1638 break; |
|
1639 } |
|
1640 /* |
|
1641 * Insert TITLE (fading) text * |
|
1642 */ |
|
1643 case EVeiCmdEditVideoViewInsertTextTitleFading: |
|
1644 { |
|
1645 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewInsertTextTitleFading" ); |
|
1646 |
|
1647 if ( IsEnoughFreeSpaceToSaveL()) |
|
1648 { |
|
1649 |
|
1650 StoreOrientation(); |
|
1651 CleanupStack::PushL( TCleanupItem( CleanupRestoreOrientation, this )); |
|
1652 AppUi()->SetOrientationL( CAknAppUiBase::EAppUiOrientationPortrait ); |
|
1653 |
|
1654 TSize res = TSize( iMovie->Resolution()); |
|
1655 CVeiTitleClipGenerator* generator = CVeiTitleClipGenerator::NewLC( res, |
|
1656 EVeiTitleClipTransitionNone, |
|
1657 EVeiTitleClipHorizontalAlignmentCenter, |
|
1658 EVeiTitleClipVerticalAlignmentCenter ); |
|
1659 |
|
1660 HBufC* descriptiveName = StringLoader::LoadLC( R_VEI_EDIT_VIEW_TITLE_FADING_NAME, iEikonEnv ); |
|
1661 generator->SetDescriptiveNameL( *descriptiveName ); |
|
1662 CleanupStack::PopAndDestroy( descriptiveName ); |
|
1663 |
|
1664 generator->SetTransitionAndAlignmentsL( EVeiTitleClipTransitionFade, |
|
1665 EVeiTitleClipHorizontalAlignmentCenter, |
|
1666 EVeiTitleClipVerticalAlignmentCenter ); |
|
1667 /* Ask for text. */ |
|
1668 HBufC* text = HBufC::NewLC( KTitleScreenMaxTextLength ); |
|
1669 TPtr txtptr( text->Des()); |
|
1670 |
|
1671 CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL( txtptr ); |
|
1672 CleanupStack::PushL( textQuery ); |
|
1673 |
|
1674 textQuery->SetMaxLength( KTitleScreenMaxTextLength ); |
|
1675 //textQuery->SetPredictiveTextInputPermitted(ETrue); |
|
1676 CleanupStack::Pop( textQuery ); |
|
1677 |
|
1678 if ( !textQuery->ExecuteLD( R_VEI_EDITVIDEO_TITLESCREEN_TEXT_QUERY )) |
|
1679 { |
|
1680 CleanupStack::PopAndDestroy( text ); |
|
1681 CleanupStack::PopAndDestroy( generator ); |
|
1682 CleanupStack::PopAndDestroy( this ); // restore appui orientation |
|
1683 break; |
|
1684 } |
|
1685 |
|
1686 generator->SetTextL( *text ); |
|
1687 CleanupStack::PopAndDestroy( text ); |
|
1688 |
|
1689 /* Insert generator into the movie. */ |
|
1690 TInt err = 0; |
|
1691 index = ( iContainer->CurrentIndex() == iMovie->VideoClipCount()) ? iMovie->VideoClipCount(): iContainer->CurrentIndex() + 1; |
|
1692 TRAP( err, iMovie->InsertVideoClipL( *generator, ETrue, index )); |
|
1693 CleanupStack::Pop( generator ); |
|
1694 User::LeaveIfError( err ); |
|
1695 |
|
1696 CleanupStack::PopAndDestroy( this ); // restore appui orientation |
|
1697 } |
|
1698 break; |
|
1699 } |
|
1700 /* |
|
1701 * Insert SUBTITLE text * |
|
1702 */ |
|
1703 case EVeiCmdEditVideoViewInsertTextSubTitle: |
|
1704 { |
|
1705 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewInsertTextSubTitle" ); |
|
1706 |
|
1707 if ( IsEnoughFreeSpaceToSaveL()) |
|
1708 { |
|
1709 StoreOrientation(); |
|
1710 CleanupStack::PushL( TCleanupItem( CleanupRestoreOrientation, this )); |
|
1711 AppUi()->SetOrientationL( CAknAppUiBase::EAppUiOrientationPortrait ); |
|
1712 |
|
1713 TSize res = TSize( iMovie->Resolution()); |
|
1714 CVeiTitleClipGenerator* generator = CVeiTitleClipGenerator::NewLC( res, |
|
1715 EVeiTitleClipTransitionNone, |
|
1716 EVeiTitleClipHorizontalAlignmentCenter, |
|
1717 EVeiTitleClipVerticalAlignmentCenter ); |
|
1718 |
|
1719 HBufC* descriptiveName = StringLoader::LoadLC( R_VEI_EDIT_VIEW_SUBTITLE_NAME, iEikonEnv ); |
|
1720 generator->SetDescriptiveNameL( *descriptiveName ); |
|
1721 CleanupStack::PopAndDestroy( descriptiveName ); |
|
1722 |
|
1723 generator->SetTransitionAndAlignmentsL( EVeiTitleClipTransitionNone, |
|
1724 EVeiTitleClipHorizontalAlignmentLeft, |
|
1725 EVeiTitleClipVerticalAlignmentBottom ); |
|
1726 |
|
1727 /* Ask for text. */ |
|
1728 HBufC* text = HBufC::NewLC( KTitleScreenMaxTextLength ); |
|
1729 TPtr txtptr( text->Des()); |
|
1730 CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL( txtptr ); |
|
1731 CleanupStack::PushL( textQuery ); |
|
1732 |
|
1733 textQuery->SetMaxLength( KTitleScreenMaxTextLength ); |
|
1734 //textQuery->SetPredictiveTextInputPermitted(ETrue); |
|
1735 CleanupStack::Pop( textQuery ); |
|
1736 |
|
1737 if ( !textQuery->ExecuteLD( R_VEI_EDITVIDEO_TITLESCREEN_TEXT_QUERY )) |
|
1738 { |
|
1739 CleanupStack::PopAndDestroy( text ); |
|
1740 CleanupStack::PopAndDestroy( generator ); |
|
1741 CleanupStack::PopAndDestroy( this ); // restore appui orientation |
|
1742 break; |
|
1743 } |
|
1744 |
|
1745 generator->SetTextL( *text ); |
|
1746 CleanupStack::PopAndDestroy( text ); |
|
1747 |
|
1748 /* Insert generator into the movie. */ |
|
1749 TInt err = 0; |
|
1750 index = ( iContainer->CurrentIndex() == iMovie->VideoClipCount()) ? iMovie->VideoClipCount(): iContainer->CurrentIndex() + 1; |
|
1751 TRAP( err, iMovie->InsertVideoClipL( *generator, ETrue, index )); |
|
1752 CleanupStack::Pop( generator ); |
|
1753 User::LeaveIfError( err ); |
|
1754 |
|
1755 CleanupStack::PopAndDestroy( this ); // restore appui orientation |
|
1756 } |
|
1757 break; |
|
1758 } |
|
1759 /* |
|
1760 * Insert SUBTITLE (fading) text * |
|
1761 */ |
|
1762 case EVeiCmdEditVideoViewInsertTextSubTitleFading: |
|
1763 { |
|
1764 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewInsertTextSubTitleFading" ); |
|
1765 |
|
1766 if ( IsEnoughFreeSpaceToSaveL()) |
|
1767 { |
|
1768 StoreOrientation(); |
|
1769 CleanupStack::PushL( TCleanupItem( CleanupRestoreOrientation, this )); |
|
1770 AppUi()->SetOrientationL( CAknAppUiBase::EAppUiOrientationPortrait ); |
|
1771 |
|
1772 TSize res = TSize( iMovie->Resolution()); |
|
1773 CVeiTitleClipGenerator* generator = CVeiTitleClipGenerator::NewLC( res, |
|
1774 EVeiTitleClipTransitionNone, |
|
1775 EVeiTitleClipHorizontalAlignmentCenter, |
|
1776 EVeiTitleClipVerticalAlignmentCenter ); |
|
1777 |
|
1778 HBufC* descriptiveName = StringLoader::LoadLC( R_VEI_EDIT_VIEW_SUBTITLE_FADING_NAME, iEikonEnv ); |
|
1779 generator->SetDescriptiveNameL( *descriptiveName ); |
|
1780 CleanupStack::PopAndDestroy( descriptiveName ); |
|
1781 |
|
1782 generator->SetTransitionAndAlignmentsL( EVeiTitleClipTransitionFade, |
|
1783 EVeiTitleClipHorizontalAlignmentLeft, |
|
1784 EVeiTitleClipVerticalAlignmentBottom ); |
|
1785 |
|
1786 /* Ask for text. */ |
|
1787 HBufC* text = HBufC::NewLC( KTitleScreenMaxTextLength ); |
|
1788 TPtr txtptr( text->Des()); |
|
1789 CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL( txtptr ); |
|
1790 CleanupStack::PushL( textQuery ); |
|
1791 |
|
1792 textQuery->SetMaxLength( KTitleScreenMaxTextLength ); |
|
1793 //textQuery->SetPredictiveTextInputPermitted(ETrue); |
|
1794 CleanupStack::Pop( textQuery ); |
|
1795 |
|
1796 if ( !textQuery->ExecuteLD( R_VEI_EDITVIDEO_TITLESCREEN_TEXT_QUERY )) |
|
1797 { |
|
1798 CleanupStack::PopAndDestroy( text ); |
|
1799 CleanupStack::PopAndDestroy( generator ); |
|
1800 CleanupStack::PopAndDestroy( this ); // restore appui orientation |
|
1801 break; |
|
1802 } |
|
1803 |
|
1804 generator->SetTextL( *text ); |
|
1805 CleanupStack::PopAndDestroy( text ); |
|
1806 |
|
1807 /* Insert generator into the movie. */ |
|
1808 TInt err = 0; |
|
1809 index = ( iContainer->CurrentIndex() == iMovie->VideoClipCount()) ? iMovie->VideoClipCount(): iContainer->CurrentIndex() + 1; |
|
1810 TRAP( err, iMovie->InsertVideoClipL( *generator, ETrue, index )); |
|
1811 CleanupStack::Pop( generator ); |
|
1812 User::LeaveIfError( err ); |
|
1813 |
|
1814 CleanupStack::PopAndDestroy( this ); // restore appui orientation |
|
1815 } |
|
1816 break; |
|
1817 } |
|
1818 /* |
|
1819 * Insert CREDIT text * |
|
1820 */ |
|
1821 case EVeiCmdEditVideoViewInsertTextCredits: |
|
1822 { |
|
1823 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewInsertTextCredits" ); |
|
1824 |
|
1825 if ( IsEnoughFreeSpaceToSaveL()) |
|
1826 { |
|
1827 StoreOrientation(); |
|
1828 CleanupStack::PushL( TCleanupItem( CleanupRestoreOrientation, this )); |
|
1829 AppUi()->SetOrientationL( CAknAppUiBase::EAppUiOrientationPortrait ); |
|
1830 |
|
1831 TSize res = TSize( iMovie->Resolution()); |
|
1832 CVeiTitleClipGenerator* generator = CVeiTitleClipGenerator::NewLC( res, |
|
1833 EVeiTitleClipTransitionNone, |
|
1834 EVeiTitleClipHorizontalAlignmentCenter, |
|
1835 EVeiTitleClipVerticalAlignmentCenter ); |
|
1836 |
|
1837 HBufC* descriptiveName = StringLoader::LoadLC( R_VEI_EDIT_VIEW_CREDITS_NAME, iEikonEnv ); |
|
1838 generator->SetDescriptiveNameL( *descriptiveName ); |
|
1839 CleanupStack::PopAndDestroy( descriptiveName ); |
|
1840 |
|
1841 generator->SetTransitionAndAlignmentsL( EVeiTitleClipTransitionScrollBottomToTop, |
|
1842 EVeiTitleClipHorizontalAlignmentCenter, |
|
1843 EVeiTitleClipVerticalAlignmentCenter ); |
|
1844 |
|
1845 /* Ask for text. */ |
|
1846 HBufC* text = HBufC::NewLC( KTitleScreenMaxTextLength ); |
|
1847 TPtr txtptr( text->Des()); |
|
1848 CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL( txtptr ); |
|
1849 CleanupStack::PushL( textQuery ); |
|
1850 |
|
1851 textQuery->SetMaxLength( KTitleScreenMaxTextLength ); |
|
1852 //textQuery->SetPredictiveTextInputPermitted(ETrue); |
|
1853 CleanupStack::Pop( textQuery ); |
|
1854 |
|
1855 if ( !textQuery->ExecuteLD( R_VEI_EDITVIDEO_TITLESCREEN_TEXT_QUERY )) |
|
1856 { |
|
1857 CleanupStack::PopAndDestroy( text ); |
|
1858 CleanupStack::PopAndDestroy( generator ); |
|
1859 CleanupStack::PopAndDestroy( this ); |
|
1860 break; |
|
1861 } |
|
1862 generator->SetTextL( *text ); |
|
1863 CleanupStack::PopAndDestroy( text ); |
|
1864 |
|
1865 /* Insert generator into the movie. */ |
|
1866 TInt err = 0; |
|
1867 index = ( iContainer->CurrentIndex() == iMovie->VideoClipCount()) ? iMovie->VideoClipCount(): iContainer->CurrentIndex() + 1; |
|
1868 TRAP( err, iMovie->InsertVideoClipL( *generator, ETrue, index )); |
|
1869 CleanupStack::Pop( generator ); |
|
1870 User::LeaveIfError( err ); |
|
1871 |
|
1872 CleanupStack::PopAndDestroy( this ); // restore appui orientation |
|
1873 } |
|
1874 break; |
|
1875 } |
|
1876 |
|
1877 /* |
|
1878 * Edit Text * |
|
1879 */ |
|
1880 case EVeiCmdEditVideoViewEditTextMove: |
|
1881 { |
|
1882 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextMove" ); |
|
1883 if ( IsEnoughFreeSpaceToSaveL()) |
|
1884 { |
|
1885 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OK_CANCEL ); |
|
1886 Cba()->DrawDeferred(); |
|
1887 |
|
1888 index = iContainer->CurrentIndex(); |
|
1889 |
|
1890 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnClip ) |
|
1891 { |
|
1892 iOriginalVideoClipIndex = index; |
|
1893 } |
|
1894 else |
|
1895 { |
|
1896 User::Panic( _L( "VideoEditor" ), 34 ); |
|
1897 } |
|
1898 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeMove ); |
|
1899 UpdateEditNaviLabel(); |
|
1900 } |
|
1901 break; |
|
1902 } |
|
1903 case EVeiCmdEditVideoViewEditTextChangeDuration: |
|
1904 { |
|
1905 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextChangeDuration" ); |
|
1906 if ( IsEnoughFreeSpaceToSaveL()) |
|
1907 { |
|
1908 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OK_CANCEL ); |
|
1909 Cba()->DrawDeferred(); |
|
1910 index = iContainer->CurrentIndex(); |
|
1911 |
|
1912 iOriginalVideoStartPoint = iMovie->VideoClipStartTime( index ); |
|
1913 iOriginalVideoCutInTime = iMovie->VideoClipCutInTime( index ); |
|
1914 iOriginalVideoCutOutTime = iMovie->VideoClipCutOutTime( index ); |
|
1915 |
|
1916 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeDuration ); |
|
1917 UpdateEditNaviLabel(); |
|
1918 } |
|
1919 break; |
|
1920 } |
|
1921 case EVeiCmdEditVideoViewEditTextChangeText: |
|
1922 { |
|
1923 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextChangeText" ); |
|
1924 if ( IsEnoughFreeSpaceToSaveL()) |
|
1925 { |
|
1926 StoreOrientation(); |
|
1927 CleanupStack::PushL( TCleanupItem( CleanupRestoreOrientation, this )); |
|
1928 AppUi()->SetOrientationL( CAknAppUiBase::EAppUiOrientationPortrait ); |
|
1929 |
|
1930 Cba()->DrawDeferred(); |
|
1931 CVedVideoClipInfo* info = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
1932 |
|
1933 CVeiTitleClipGenerator* generator = STATIC_CAST( CVeiTitleClipGenerator* , info->Generator()); |
|
1934 HBufC* text = HBufC::NewLC( KTitleScreenMaxTextLength ); |
|
1935 *text = (( CVeiTitleClipGenerator* )info->Generator())->Text(); |
|
1936 |
|
1937 TPtr txtptr( text->Des()); |
|
1938 CAknTextQueryDialog* textQuery = CAknTextQueryDialog::NewL( txtptr ); |
|
1939 CleanupStack::PushL( textQuery ); |
|
1940 |
|
1941 textQuery->SetMaxLength( KTitleScreenMaxTextLength ); |
|
1942 //textQuery->SetPredictiveTextInputPermitted(ETrue); |
|
1943 CleanupStack::Pop( textQuery ); |
|
1944 |
|
1945 if ( !textQuery->ExecuteLD( R_VEI_EDITVIDEO_TITLESCREEN_TEXT_QUERY )) |
|
1946 { |
|
1947 CleanupStack::PopAndDestroy( text ); |
|
1948 CleanupStack::PopAndDestroy( this ); // restore appui orientation |
|
1949 break; |
|
1950 } |
|
1951 generator->SetTextL( *text ); |
|
1952 CleanupStack::PopAndDestroy( text ); |
|
1953 UpdateEditNaviLabel(); |
|
1954 |
|
1955 CleanupStack::PopAndDestroy( this ); // restore appui orientation |
|
1956 } |
|
1957 break; |
|
1958 } |
|
1959 |
|
1960 case EVeiCmdEditVideoViewEditTextSetTextColor: |
|
1961 { |
|
1962 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextSetTextColor" ); |
|
1963 if ( IsEnoughFreeSpaceToSaveL()) |
|
1964 { |
|
1965 CVedVideoClipInfo* info = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
1966 CVeiTitleClipGenerator* generator = STATIC_CAST( CVeiTitleClipGenerator* , info->Generator()); |
|
1967 |
|
1968 TRgb color = generator->TextColor(); |
|
1969 if ( !iPopup->ShowColorSelectorL( color )) |
|
1970 { |
|
1971 break; |
|
1972 } |
|
1973 generator->SetTextColorL( color ); |
|
1974 } |
|
1975 break; |
|
1976 } |
|
1977 case EVeiCmdEditVideoViewEditTextSetBackGround: |
|
1978 { |
|
1979 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextSetBackGround" ); |
|
1980 if ( IsEnoughFreeSpaceToSaveL()) |
|
1981 { |
|
1982 CVedVideoClipInfo* info = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
1983 CVeiTitleClipGenerator* generator = STATIC_CAST( CVeiTitleClipGenerator* , info->Generator()); |
|
1984 |
|
1985 // ask for color or image |
|
1986 TBool imageSelected; |
|
1987 TInt err = iPopup->ShowTitleScreenBackgroundSelectionPopupL( imageSelected ); |
|
1988 if ( err != KErrNone ) |
|
1989 { |
|
1990 break; |
|
1991 } |
|
1992 |
|
1993 if ( imageSelected ) |
|
1994 { |
|
1995 CDesCArrayFlat* selectedFiles = new( ELeave )CDesCArrayFlat( 1 ); |
|
1996 CleanupStack::PushL( selectedFiles ); |
|
1997 |
|
1998 CVeiMGFetchVerifier* mgFetchVerifier = CVeiMGFetchVerifier::NewLC(); |
|
1999 |
|
2000 if ( MGFetch::RunL( *selectedFiles, EImageFile, EFalse, mgFetchVerifier ) == EFalse ) |
|
2001 { |
|
2002 /* User cancelled the dialog. */ |
|
2003 CleanupStack::PopAndDestroy( mgFetchVerifier ); |
|
2004 CleanupStack::PopAndDestroy( selectedFiles ); |
|
2005 break; |
|
2006 } |
|
2007 |
|
2008 CleanupStack::PopAndDestroy( mgFetchVerifier ); |
|
2009 |
|
2010 if ( !iWaitDialog ) |
|
2011 { |
|
2012 iWaitDialog = new( ELeave )CAknWaitDialog( REINTERPRET_CAST( CEikDialog** , &iWaitDialog ), ETrue ); |
|
2013 iWaitDialog->ExecuteLD( R_VEI_WAIT_DIALOG_INSERTING_IMAGE ); |
|
2014 } |
|
2015 |
|
2016 |
|
2017 TRAP( err, generator->SetBackgroundImageL(( *selectedFiles )[0], * this )); |
|
2018 |
|
2019 if ( err ) |
|
2020 { |
|
2021 if ( iWaitDialog ) |
|
2022 { |
|
2023 CancelWaitDialog(); |
|
2024 } |
|
2025 ShowErrorNote( R_VEI_ERRORNOTE_IMAGE_INSERTING_FAILED ); |
|
2026 } |
|
2027 |
|
2028 CleanupStack::PopAndDestroy( selectedFiles ); |
|
2029 } |
|
2030 else |
|
2031 { |
|
2032 TRgb color = generator->BackgroundColor(); |
|
2033 if ( !iPopup->ShowColorSelectorL( color )) |
|
2034 { |
|
2035 break; |
|
2036 } |
|
2037 generator->SetBackgroundColorL( color ); |
|
2038 } |
|
2039 } |
|
2040 break; |
|
2041 } |
|
2042 case EVeiCmdEditVideoViewEditTextStyle: |
|
2043 { |
|
2044 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextStyle" ); |
|
2045 if ( IsEnoughFreeSpaceToSaveL()) |
|
2046 { |
|
2047 /* Ask for style. */ |
|
2048 iPopup->ShowTitleScreenStyleSelectionPopupL(); |
|
2049 } |
|
2050 break; |
|
2051 } |
|
2052 /* |
|
2053 * Edit text, AddColorEffect * |
|
2054 */ |
|
2055 case EVeiCmdEditVideoViewEditTextAddColorEffect: |
|
2056 { |
|
2057 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextAddColorEffect" ); |
|
2058 if ( IsEnoughFreeSpaceToSaveL()) |
|
2059 { |
|
2060 iPopup->ShowEffectSelectionPopupListL(); |
|
2061 } |
|
2062 break; |
|
2063 } |
|
2064 /* |
|
2065 * Edit text style * |
|
2066 */ |
|
2067 case EVeiCmdEditVideoViewEditTextStyleTitle: |
|
2068 { |
|
2069 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextStyleTitle" ); |
|
2070 if ( IsEnoughFreeSpaceToSaveL()) |
|
2071 { |
|
2072 CVedVideoClipInfo* info = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
2073 |
|
2074 CVeiTitleClipGenerator* generator = STATIC_CAST( CVeiTitleClipGenerator* , info->Generator()); |
|
2075 |
|
2076 HBufC* descriptiveName = StringLoader::LoadLC( R_VEI_EDIT_VIEW_TITLE_NAME, iEikonEnv ); |
|
2077 generator->SetDescriptiveNameL( *descriptiveName ); |
|
2078 CleanupStack::PopAndDestroy( descriptiveName ); |
|
2079 |
|
2080 generator->SetTransitionAndAlignmentsL( EVeiTitleClipTransitionNone, |
|
2081 EVeiTitleClipHorizontalAlignmentCenter, |
|
2082 EVeiTitleClipVerticalAlignmentCenter ); |
|
2083 } |
|
2084 break; |
|
2085 } |
|
2086 case EVeiCmdEditVideoViewEditTextStyleTitleFading: |
|
2087 { |
|
2088 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextStyleTitleFading" ); |
|
2089 if ( IsEnoughFreeSpaceToSaveL()) |
|
2090 { |
|
2091 CVedVideoClipInfo* info = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
2092 |
|
2093 CVeiTitleClipGenerator* generator = STATIC_CAST( CVeiTitleClipGenerator* , info->Generator()); |
|
2094 |
|
2095 HBufC* descriptiveName = StringLoader::LoadLC( R_VEI_EDIT_VIEW_TITLE_FADING_NAME, iEikonEnv ); |
|
2096 generator->SetDescriptiveNameL( *descriptiveName ); |
|
2097 CleanupStack::PopAndDestroy( descriptiveName ); |
|
2098 generator->SetTransitionAndAlignmentsL( EVeiTitleClipTransitionFade, |
|
2099 EVeiTitleClipHorizontalAlignmentCenter, |
|
2100 EVeiTitleClipVerticalAlignmentCenter ); |
|
2101 } |
|
2102 break; |
|
2103 } |
|
2104 case EVeiCmdEditVideoViewEditTextStyleSubTitle: |
|
2105 { |
|
2106 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextStyleSubTitle" ); |
|
2107 if ( IsEnoughFreeSpaceToSaveL()) |
|
2108 { |
|
2109 CVedVideoClipInfo* info = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
2110 |
|
2111 CVeiTitleClipGenerator* generator = STATIC_CAST( CVeiTitleClipGenerator* , info->Generator()); |
|
2112 |
|
2113 HBufC* descriptiveName = StringLoader::LoadLC( R_VEI_EDIT_VIEW_SUBTITLE_NAME, iEikonEnv ); |
|
2114 generator->SetDescriptiveNameL( *descriptiveName ); |
|
2115 CleanupStack::PopAndDestroy( descriptiveName ); |
|
2116 generator->SetTransitionAndAlignmentsL( EVeiTitleClipTransitionNone, |
|
2117 EVeiTitleClipHorizontalAlignmentLeft, |
|
2118 EVeiTitleClipVerticalAlignmentBottom ); |
|
2119 |
|
2120 } |
|
2121 break; |
|
2122 } |
|
2123 case EVeiCmdEditVideoViewEditTextStyleSubTitleFading: |
|
2124 { |
|
2125 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextStyleSubTitleFading" ); |
|
2126 if ( IsEnoughFreeSpaceToSaveL()) |
|
2127 { |
|
2128 CVedVideoClipInfo* info = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
2129 |
|
2130 CVeiTitleClipGenerator* generator = STATIC_CAST( CVeiTitleClipGenerator* , info->Generator()); |
|
2131 |
|
2132 HBufC* descriptiveName = StringLoader::LoadLC( R_VEI_EDIT_VIEW_SUBTITLE_FADING_NAME, iEikonEnv ); |
|
2133 generator->SetDescriptiveNameL( *descriptiveName ); |
|
2134 CleanupStack::PopAndDestroy( descriptiveName ); |
|
2135 generator->SetTransitionAndAlignmentsL( EVeiTitleClipTransitionFade, |
|
2136 EVeiTitleClipHorizontalAlignmentLeft, |
|
2137 EVeiTitleClipVerticalAlignmentBottom ); |
|
2138 } |
|
2139 break; |
|
2140 } |
|
2141 case EVeiCmdEditVideoViewEditTextStyleCredit: |
|
2142 { |
|
2143 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextStyleCredit" ); |
|
2144 if ( IsEnoughFreeSpaceToSaveL()) |
|
2145 { |
|
2146 CVedVideoClipInfo* info = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
2147 |
|
2148 CVeiTitleClipGenerator* generator = STATIC_CAST( CVeiTitleClipGenerator* , info->Generator()); |
|
2149 |
|
2150 HBufC* descriptiveName = StringLoader::LoadLC( R_VEI_EDIT_VIEW_CREDITS_NAME, iEikonEnv ); |
|
2151 generator->SetDescriptiveNameL( *descriptiveName ); |
|
2152 CleanupStack::PopAndDestroy( descriptiveName ); |
|
2153 generator->SetTransitionAndAlignmentsL( EVeiTitleClipTransitionScrollBottomToTop, |
|
2154 EVeiTitleClipHorizontalAlignmentCenter, |
|
2155 EVeiTitleClipVerticalAlignmentCenter ); |
|
2156 } |
|
2157 break; |
|
2158 } |
|
2159 /* |
|
2160 * Edit text, Duplicate * |
|
2161 */ |
|
2162 case EVeiCmdEditVideoViewEditTextDuplicate: |
|
2163 { |
|
2164 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditTextDuplicate" ); |
|
2165 if ( IsEnoughFreeSpaceToSaveL()) |
|
2166 { |
|
2167 CVedVideoClipInfo* previousInfo = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
2168 CVeiTitleClipGenerator* generator = STATIC_CAST( CVeiTitleClipGenerator* , previousInfo->Generator()); |
|
2169 |
|
2170 iWaitMode = EDuplicating; |
|
2171 |
|
2172 CVeiTitleClipGenerator* generator2 = CVeiTitleClipGenerator::NewLC( iMovie->Resolution(), |
|
2173 generator->Transition(), |
|
2174 generator->HorizontalAlignment(), |
|
2175 generator->VerticalAlignment()); |
|
2176 |
|
2177 generator2->SetDescriptiveNameL( generator->DescriptiveName()); |
|
2178 generator2->SetTransitionAndAlignmentsL( generator->Transition(), |
|
2179 generator->HorizontalAlignment(), |
|
2180 generator->VerticalAlignment() ); |
|
2181 generator2->SetTextL( generator->Text()); |
|
2182 generator2->SetTextColorL( generator->TextColor()); |
|
2183 |
|
2184 generator2->SetBackgroundColorL( generator->BackgroundColor()); |
|
2185 if ( generator->BackgroundImage()) |
|
2186 { |
|
2187 generator2->SetBackgroundImageL( generator->BackgroundImage()); |
|
2188 } |
|
2189 |
|
2190 generator2->SetDuration( generator->Duration()); |
|
2191 |
|
2192 TInt err = 0; |
|
2193 index = ( iContainer->CurrentIndex() == iMovie->VideoClipCount()) ? iMovie->VideoClipCount(): iContainer->CurrentIndex() + 1; |
|
2194 TRAP( err, iMovie->InsertVideoClipL( *generator2, ETrue, index )); |
|
2195 |
|
2196 CleanupStack::Pop( generator2 ); |
|
2197 User::LeaveIfError( err ); |
|
2198 } |
|
2199 break; |
|
2200 } |
|
2201 /** |
|
2202 * Insert Image |
|
2203 */ |
|
2204 case EVeiCmdEditVideoViewInsertImage: |
|
2205 { |
|
2206 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewInsertImage" ); |
|
2207 if ( IsEnoughFreeSpaceToSaveL()) |
|
2208 { |
|
2209 TTimeIntervalMicroSeconds duration( 5000000 ); |
|
2210 |
|
2211 CDesCArrayFlat* selectedFiles = new( ELeave )CDesCArrayFlat( 1 ); |
|
2212 CleanupStack::PushL( selectedFiles ); |
|
2213 |
|
2214 CVeiMGFetchVerifier* mgFetchVerifier = CVeiMGFetchVerifier::NewLC(); |
|
2215 |
|
2216 if ( MGFetch::RunL( *selectedFiles, EImageFile, EFalse, mgFetchVerifier ) == EFalse ) |
|
2217 { |
|
2218 /* User cancelled the dialog. */ |
|
2219 CleanupStack::PopAndDestroy( mgFetchVerifier ); |
|
2220 CleanupStack::PopAndDestroy( selectedFiles ); |
|
2221 break; |
|
2222 } |
|
2223 |
|
2224 CleanupStack::PopAndDestroy( mgFetchVerifier ); |
|
2225 |
|
2226 if ( !iWaitDialog ) |
|
2227 { |
|
2228 iWaitDialog = new( ELeave )CAknWaitDialog( REINTERPRET_CAST( CEikDialog** , &iWaitDialog ), ETrue ); |
|
2229 iWaitDialog->ExecuteLD( R_VEI_WAIT_DIALOG_INSERTING_IMAGE ); |
|
2230 } |
|
2231 |
|
2232 RFs& fs = iEikonEnv->FsSession(); |
|
2233 |
|
2234 TRAPD( err, iGenerator = CVeiImageClipGenerator::NewL(( *selectedFiles )[0], |
|
2235 TSize( KMaxVideoFrameResolutionX, KMaxVideoFrameResolutionY ), |
|
2236 duration, |
|
2237 KRgbBlack, |
|
2238 KVideoClipGenetatorDisplayMode, |
|
2239 fs, |
|
2240 *this )); |
|
2241 if ( err ) |
|
2242 { |
|
2243 if ( iWaitDialog ) |
|
2244 { |
|
2245 CancelWaitDialog(); |
|
2246 } |
|
2247 ShowErrorNote( R_VEI_ERRORNOTE_IMAGE_INSERTING_FAILED ); |
|
2248 } |
|
2249 |
|
2250 CleanupStack::PopAndDestroy( selectedFiles ); |
|
2251 } |
|
2252 break; |
|
2253 } |
|
2254 |
|
2255 /** |
|
2256 * Edit Image * |
|
2257 */ |
|
2258 case EVeiCmdEditVideoViewEditImageMove: |
|
2259 { |
|
2260 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditImageMove" ); |
|
2261 if ( IsEnoughFreeSpaceToSaveL()) |
|
2262 { |
|
2263 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OK_CANCEL ); |
|
2264 Cba()->DrawDeferred(); |
|
2265 |
|
2266 index = iContainer->CurrentIndex(); |
|
2267 |
|
2268 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnClip ) |
|
2269 { |
|
2270 iOriginalVideoClipIndex = index; |
|
2271 } |
|
2272 else |
|
2273 { |
|
2274 User::Panic( _L( "VideoEditor" ), 34 ); |
|
2275 } |
|
2276 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeMove ); |
|
2277 UpdateEditNaviLabel(); |
|
2278 } |
|
2279 break; |
|
2280 } |
|
2281 |
|
2282 case EVeiCmdEditVideoViewEditImageChangeDuration: |
|
2283 { |
|
2284 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditImageChangeDuration" ); |
|
2285 if ( IsEnoughFreeSpaceToSaveL()) |
|
2286 { |
|
2287 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OK_CANCEL ); |
|
2288 Cba()->DrawDeferred(); |
|
2289 index = iContainer->CurrentIndex(); |
|
2290 |
|
2291 iOriginalVideoStartPoint = iMovie->VideoClipStartTime( index ); |
|
2292 iOriginalVideoCutInTime = iMovie->VideoClipCutInTime( index ); |
|
2293 iOriginalVideoCutOutTime = iMovie->VideoClipCutOutTime( index ); |
|
2294 |
|
2295 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeDuration ); |
|
2296 UpdateEditNaviLabel(); |
|
2297 } |
|
2298 break; |
|
2299 } |
|
2300 case EVeiCmdEditVideoViewEditImageBackGround: |
|
2301 { |
|
2302 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditImageBackGround" ); |
|
2303 if ( IsEnoughFreeSpaceToSaveL()) |
|
2304 { |
|
2305 CVedVideoClipInfo* info = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
2306 CVeiImageClipGenerator* generator = STATIC_CAST( CVeiImageClipGenerator* , info->Generator()); |
|
2307 |
|
2308 // ask for color |
|
2309 TRgb color = generator->BackgroundColor(); |
|
2310 if ( !iPopup->ShowColorSelectorL( color )) |
|
2311 { |
|
2312 break; |
|
2313 } |
|
2314 |
|
2315 generator->SetBackgroundColor( color ); |
|
2316 } |
|
2317 break; |
|
2318 } |
|
2319 case EVeiCmdEditVideoViewEditImageAddColorEffect: |
|
2320 { |
|
2321 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditImageAddColorEffect" ); |
|
2322 if ( IsEnoughFreeSpaceToSaveL()) |
|
2323 { |
|
2324 iPopup->ShowEffectSelectionPopupListL(); |
|
2325 } |
|
2326 break; |
|
2327 } |
|
2328 // * DUPLICATE Image * |
|
2329 case EVeiCmdEditVideoViewEditImageDuplicate: |
|
2330 { |
|
2331 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditImageDuplicate" ); |
|
2332 if ( IsEnoughFreeSpaceToSaveL()) |
|
2333 { |
|
2334 CVedVideoClipInfo* previousInfo = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
2335 CVeiImageClipGenerator* generator = STATIC_CAST( CVeiImageClipGenerator* , previousInfo->Generator()); |
|
2336 |
|
2337 RFs& fs = iEikonEnv->FsSession(); |
|
2338 |
|
2339 iWaitMode = EDuplicating; |
|
2340 |
|
2341 iGenerator = CVeiImageClipGenerator::NewL( generator->ImageFilename(), |
|
2342 TSize( KMaxVideoFrameResolutionX, KMaxVideoFrameResolutionY ), |
|
2343 previousInfo->Duration(), |
|
2344 generator->BackgroundColor(), |
|
2345 KVideoClipGenetatorDisplayMode, |
|
2346 fs, |
|
2347 *this ); |
|
2348 } |
|
2349 break; |
|
2350 } |
|
2351 |
|
2352 /** |
|
2353 * Insert -> Sound clip |
|
2354 */ |
|
2355 case EVeiCmdEditVideoViewInsertAudio: |
|
2356 { |
|
2357 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewInsertAudio" ); |
|
2358 if ( IsEnoughFreeSpaceToSaveL()) |
|
2359 { |
|
2360 if ( !iMediaQueue->ShowAudioClipDialogL()) |
|
2361 { |
|
2362 break; |
|
2363 } |
|
2364 } |
|
2365 HandleScreenDeviceChangedL(); |
|
2366 break; |
|
2367 } |
|
2368 /** |
|
2369 * Insert -> New sound clip |
|
2370 */ |
|
2371 case EVeiCmdEditVideoViewInsertNewAudio: |
|
2372 { |
|
2373 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewInsertNewAudio" ); |
|
2374 if ( IsEnoughFreeSpaceToSaveL()) |
|
2375 { |
|
2376 InsertNewAudio(); |
|
2377 } |
|
2378 break; |
|
2379 } |
|
2380 |
|
2381 case EVeiCmdEditVideoViewEditAudioSetDuration: |
|
2382 { |
|
2383 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditAudioSetDuration" ); |
|
2384 if ( IsEnoughFreeSpaceToSaveL()) |
|
2385 { |
|
2386 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OK_CANCEL ); |
|
2387 Cba()->DrawDeferred(); |
|
2388 index = iContainer->CurrentIndex(); |
|
2389 |
|
2390 iOriginalAudioStartPoint = iMovie->AudioClipStartTime( index ); |
|
2391 iOriginalAudioDuration = iMovie->AudioClipEditedDuration( index ); |
|
2392 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeDuration ); |
|
2393 UpdateEditNaviLabel(); |
|
2394 } |
|
2395 break; |
|
2396 } |
|
2397 case EVeiCmdEditVideoViewSettings: |
|
2398 { |
|
2399 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewSettings" ); |
|
2400 AppUi()->ActivateLocalViewL( TUid::Uid( EVeiSettingsView )); |
|
2401 break; |
|
2402 } |
|
2403 case EVeiCmdEditVideoViewRecord: |
|
2404 { |
|
2405 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewRecord" ); |
|
2406 if ( IsEnoughFreeSpaceToSaveL()) |
|
2407 { |
|
2408 /* Set the mode, CBAs and Navi label. */ |
|
2409 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeRecording ); |
|
2410 |
|
2411 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_EMPTY ); |
|
2412 Cba()->DrawDeferred(); |
|
2413 UpdateEditNaviLabel(); |
|
2414 |
|
2415 iRecordedAudioMaxDuration = TTimeIntervalMicroSeconds( - 1 ); |
|
2416 for ( TInt i = 0; i < iMovie->AudioClipCount(); i++ ) |
|
2417 { |
|
2418 |
|
2419 if ( iMovie->AudioClipStartTime( i ) > iContainer->RecordedAudioStartTime()) |
|
2420 { |
|
2421 TInt64 startTimeInt = iContainer->RecordedAudioStartTime().Int64(); |
|
2422 TInt64 nextStartTimeInt = iMovie->AudioClipStartTime( i ).Int64(); |
|
2423 iRecordedAudioMaxDuration = TTimeIntervalMicroSeconds( nextStartTimeInt - startTimeInt ); |
|
2424 break; |
|
2425 } |
|
2426 } |
|
2427 |
|
2428 iRecorder->RecordL(); |
|
2429 const TUint delay = 1000 * 1000 / 10; |
|
2430 |
|
2431 iAudioRecordPeriodic->Start( delay, delay, TCallBack( CVeiEditVideoView::UpdateAudioRecording, this )); |
|
2432 |
|
2433 iContainer->SetRecordedAudioDuration( TTimeIntervalMicroSeconds( 0 )); |
|
2434 } |
|
2435 break; |
|
2436 } |
|
2437 case EVeiCmdEditVideoViewRecordCancel: |
|
2438 { |
|
2439 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewRecordCancel" ); |
|
2440 // cancel recording |
|
2441 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
2442 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); |
|
2443 iContainer->SetRecordedAudioStartTime( TTimeIntervalMicroSeconds( 0 )); |
|
2444 iContainer->SetCursorLocation( VideoEditor::ECursorOnAudio ); |
|
2445 Cba()->DrawDeferred(); |
|
2446 |
|
2447 UpdateEditNaviLabel(); |
|
2448 break; |
|
2449 } |
|
2450 /* |
|
2451 * Stop previewing |
|
2452 */ |
|
2453 case EVeiCmdPlayViewStop: |
|
2454 case EVeiCmdCutVideoViewStop: |
|
2455 case EVeiCmdEditVideoViewRecordStop: |
|
2456 { |
|
2457 LOG( KVideoEditorLogFile, "\tEVeiCmdPlayViewStop||EVeiCmdCutVideoViewStop||EVeiCmdEditVideoViewRecordStop" ); |
|
2458 if ( EditorState() == EQuickPreview ) |
|
2459 { |
|
2460 iContainer->StopVideo( EFalse ); |
|
2461 iContainer->SetFinishedStatus( ETrue ); |
|
2462 StopNaviPaneUpdateL(); |
|
2463 LOG( KVideoEditorLogFile, "\tEVeiCmdPlayViewStop||EVeiCmdCutVideoViewStop||EVeiCmdEditVideoViewRecordStop, setting R_VEI_SOFTKEYS_PREVIEW_PLAY_BACK" ); |
|
2464 Cba()->SetCommandSetL( R_VEI_SOFTKEYS_PREVIEW_PLAY_BACK ); |
|
2465 Cba()->DrawDeferred(); |
|
2466 break; |
|
2467 } |
|
2468 |
|
2469 // stop recording |
|
2470 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
2471 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); |
|
2472 Cba()->DrawDeferred(); |
|
2473 UpdateEditNaviLabel(); |
|
2474 |
|
2475 iRecorder->Stop(); |
|
2476 iAudioRecordPeriodic->Cancel(); |
|
2477 |
|
2478 if ( iAudioClipInfo ) |
|
2479 { |
|
2480 delete iAudioClipInfo; |
|
2481 iAudioClipInfo = NULL; |
|
2482 } |
|
2483 |
|
2484 iProgressNote = new( ELeave )CAknProgressDialog( REINTERPRET_CAST( CEikDialog** , &iProgressNote ), ETrue ); |
|
2485 |
|
2486 iProgressNote->SetCallback( this ); |
|
2487 iProgressNote->ExecuteDlgLD( R_VEI_PROGRESS_NOTE ); |
|
2488 HBufC* stringholder = StringLoader::LoadL( R_VEI_PROGRESS_NOTE_INSERTING_AUDIO, iEikonEnv ); |
|
2489 CleanupStack::PushL( stringholder ); |
|
2490 |
|
2491 iProgressNote->SetTextL( *stringholder ); |
|
2492 CleanupStack::PopAndDestroy( this ); // stringholder |
|
2493 |
|
2494 iProgressNote->GetProgressInfoL()->SetFinalValue( 100 ); |
|
2495 iWaitMode = EOpeningAudioInfo; |
|
2496 |
|
2497 iAudioClipInfo = CVedAudioClipInfo::NewL( *iTempRecordedAudio, *this ); |
|
2498 break; |
|
2499 } |
|
2500 case EVeiCmdPlayViewPause: |
|
2501 case EVeiCmdEditVideoViewRecordPause: |
|
2502 { |
|
2503 LOG( KVideoEditorLogFile, "\tEVeiCmdPlayViewPause||EVeiCmdEditVideoViewRecordPause" ); |
|
2504 if ( EditorState() == EQuickPreview ) |
|
2505 { |
|
2506 iContainer->PauseVideoL(); |
|
2507 StopNaviPaneUpdateL(); |
|
2508 |
|
2509 LOG( KVideoEditorLogFile, "\tEVeiCmdPlayViewPause||EVeiCmdEditVideoViewRecordPause, setting R_VEI_SOFTKEYS_PREVIEW_PLAY_BACK" ); |
|
2510 Cba()->SetCommandSetL( R_VEI_SOFTKEYS_PREVIEW_PLAY_BACK ); |
|
2511 Cba()->DrawDeferred(); |
|
2512 } |
|
2513 else |
|
2514 { |
|
2515 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_EMPTY ); |
|
2516 Cba()->DrawDeferred(); |
|
2517 |
|
2518 // Pause recording |
|
2519 // Cba is set to CONTINUE_STOP in DoUpdateAudioRecording() |
|
2520 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeRecordingPaused ); |
|
2521 iRecorder->Stop(); |
|
2522 UpdateEditNaviLabel(); |
|
2523 } |
|
2524 break; |
|
2525 } |
|
2526 /* |
|
2527 * Preview continue: |
|
2528 */ |
|
2529 case EVeiCmdCutVideoViewPlay: |
|
2530 { |
|
2531 LOG( KVideoEditorLogFile, "\tEVeiCmdCutVideoViewPlay" ); |
|
2532 |
|
2533 if ( !iUpdateTemp && !iTempFile && 1 == iMovie->VideoClipCount() ) |
|
2534 { |
|
2535 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModePreview ); |
|
2536 iContainer->PlayVideo( iMovie->VideoClipInfo( 0 )->DescriptiveName(), iFullScreenSelected ); |
|
2537 } |
|
2538 else |
|
2539 { |
|
2540 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModePreview ); |
|
2541 iContainer->PlayVideo( *iTempFile, iFullScreenSelected ); |
|
2542 } |
|
2543 |
|
2544 // @: think should this be put under condition play was started |
|
2545 // (actually play starts when "loadingComplete" event comes to NotifyVideoDisplayEvent |
|
2546 //StartNaviPaneUpdateL(); |
|
2547 break; |
|
2548 } |
|
2549 |
|
2550 case EVeiCmdCutVideoTakeSnapshot: |
|
2551 { |
|
2552 LOG( KVideoEditorLogFile, "\tEVeiCmdCutVideoTakeSnapshot" ); |
|
2553 if ( IsEnoughFreeSpaceToSaveL()) |
|
2554 { |
|
2555 iContainer->TakeSnapshotL(); |
|
2556 } |
|
2557 break; |
|
2558 } |
|
2559 |
|
2560 case EVeiCmdCutVideoViewContinue: |
|
2561 case EVeiCmdEditVideoViewContinue: |
|
2562 { |
|
2563 LOG( KVideoEditorLogFile, "\tEVeiCmdCutVideoViewContinue||EVeiCmdEditVideoViewContinue" ); |
|
2564 if (( iRecorder->State() != CMdaAudioClipUtility::ERecording ) && |
|
2565 ( iRecorder->State() != CMdaAudioClipUtility::ENotReady ) ) |
|
2566 { |
|
2567 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_EMPTY ); |
|
2568 Cba()->DrawDeferred(); |
|
2569 |
|
2570 // Continue recording |
|
2571 iRecorder->RecordL(); |
|
2572 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeRecording ); |
|
2573 |
|
2574 UpdateEditNaviLabel(); |
|
2575 } |
|
2576 break; |
|
2577 } |
|
2578 case EVeiCmdEditVideoViewEditAudioMove: |
|
2579 case EVeiCmdEditVideoViewEditVideoMove: |
|
2580 { |
|
2581 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditAudioMove||EVeiCmdEditVideoViewEditVideoMove" ); |
|
2582 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OK_CANCEL ); |
|
2583 Cba()->DrawDeferred(); |
|
2584 |
|
2585 index = iContainer->CurrentIndex(); |
|
2586 |
|
2587 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnAudio ) |
|
2588 { |
|
2589 iOriginalAudioStartPoint = iMovie->AudioClipStartTime( index ); |
|
2590 iOriginalAudioDuration = iMovie->AudioClipEditedDuration( index ); |
|
2591 } |
|
2592 else if ( iContainer->CursorLocation() == VideoEditor::ECursorOnClip ) |
|
2593 { |
|
2594 iOriginalVideoClipIndex = index; |
|
2595 } |
|
2596 else |
|
2597 { |
|
2598 User::Panic( _L( "VideoEditor" ), 34 ); |
|
2599 } |
|
2600 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeMove ); |
|
2601 UpdateEditNaviLabel(); |
|
2602 break; |
|
2603 } |
|
2604 /** |
|
2605 * Edit video clip -> Add colour effect |
|
2606 */ |
|
2607 case EVeiCmdEditVideoViewEditVideoColorEffect: |
|
2608 { |
|
2609 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditVideoColorEffect" ); |
|
2610 if ( IsEnoughFreeSpaceToSaveL()) |
|
2611 { |
|
2612 iPopup->ShowEffectSelectionPopupListL(); |
|
2613 } |
|
2614 break; |
|
2615 } |
|
2616 /** |
|
2617 * Use slow motion |
|
2618 */ |
|
2619 case EVeiCmdEditVideoViewEditVideoSlowMotion: |
|
2620 { |
|
2621 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditVideoSlowMotion" ); |
|
2622 if ( IsEnoughFreeSpaceToSaveL()) |
|
2623 { |
|
2624 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OK_CANCEL ); |
|
2625 Cba()->DrawDeferred(); |
|
2626 iOriginalVideoSpeed = iMovie->VideoClipSpeed( iContainer->CurrentIndex()); |
|
2627 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeSlowMotion ); |
|
2628 iContainer->SetSlowMotionStartValueL( iOriginalVideoSpeed ); |
|
2629 iContainer->ArrowsControl(); |
|
2630 } |
|
2631 break; |
|
2632 } |
|
2633 case EVeiCmdEditVideoViewEditVideoMute: |
|
2634 { |
|
2635 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditVideoMute" ); |
|
2636 SetNewTempFileNeeded( ETrue ); |
|
2637 iMovie->VideoClipSetMuted( iContainer->CurrentIndex(), ETrue ); |
|
2638 break; |
|
2639 } |
|
2640 case EVeiCmdEditVideoViewEditVideoUnmute: |
|
2641 { |
|
2642 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditVideoUnmute" ); |
|
2643 SetNewTempFileNeeded( ETrue ); |
|
2644 iMovie->VideoClipSetMuted( iContainer->CurrentIndex(), EFalse ); |
|
2645 break; |
|
2646 } |
|
2647 case EVeiCmdEditVideoViewEditAudioRemove: |
|
2648 case EVeiCmdEditVideoViewEditVideoRemove: |
|
2649 case EVeiCmdEditVideoViewEditTextRemove: |
|
2650 case EVeiCmdEditVideoViewEditImageRemove: |
|
2651 { |
|
2652 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewEditAudioRemove||EVeiCmdEditVideoViewEditVideoRemove||EVeiCmdEditVideoViewEditTextRemove||EVeiCmdEditVideoViewEditImageRemove" ); |
|
2653 RemoveCurrentClipL(); |
|
2654 break; |
|
2655 } |
|
2656 /** |
|
2657 * Back |
|
2658 */ |
|
2659 case EAknSoftkeyBack: |
|
2660 { |
|
2661 LOG( KVideoEditorLogFile, "CVeiEditVideoView::HandleCommandL: EAknSoftkeyBack" ); |
|
2662 LOGFMT( KVideoEditorLogFile, "\tiFullScreenSelected: %d", iFullScreenSelected ); |
|
2663 |
|
2664 if ( EditorState() != EEdit || iFullScreenSelected ) |
|
2665 { |
|
2666 iFullScreenSelected = EFalse; |
|
2667 iContainer->StopVideo( ETrue ); |
|
2668 StopNaviPaneUpdateL(); |
|
2669 UpdateEditNaviLabel(); |
|
2670 break; |
|
2671 } |
|
2672 else if ( !iMovieSavedFlag && ( iMovie->VideoClipCount() > 0 || iMovie->AudioClipCount() > 0 )) |
|
2673 { |
|
2674 HBufC* saveConfirmationString; // String holding the text shown in dialog. |
|
2675 CAknQueryDialog* dlg; // Save confirmation dialog. |
|
2676 TInt saveEditedVideo; // Query result. |
|
2677 |
|
2678 saveConfirmationString = StringLoader::LoadLC( R_VEI_CONFIRM_EXIT_SAVE, iEikonEnv ); |
|
2679 dlg = new( ELeave )CAknQueryDialog( *saveConfirmationString, CAknQueryDialog::ENoTone ); |
|
2680 saveEditedVideo = dlg->ExecuteLD( R_VEI_CONFIRMATION_QUERY ); |
|
2681 |
|
2682 if ( !saveEditedVideo ) |
|
2683 // Do not save. |
|
2684 { |
|
2685 // Activate videos view. |
|
2686 AppUi()->HandleCommandL( EAknCmdExit ); |
|
2687 |
|
2688 iMovie->Reset(); |
|
2689 |
|
2690 iMovieSavedFlag = ETrue; // Movie is saved. |
|
2691 iMovieFirstAddFlag = ETrue; // True for the next edit process. |
|
2692 |
|
2693 AppUi()->HandleCommandL( aCommand ); |
|
2694 } |
|
2695 else |
|
2696 { |
|
2697 if ( SaveL( EProcessingMovieSaveThenQuit )) |
|
2698 // Quit after saving? |
|
2699 { |
|
2700 //iMovieSavedFlag = ETrue; // Movie is saved. |
|
2701 iMovieFirstAddFlag = ETrue; // True for the next edit process. |
|
2702 iWaitMode = EProcessingMovieSaveThenQuit; |
|
2703 } |
|
2704 } |
|
2705 |
|
2706 CleanupStack::PopAndDestroy( saveConfirmationString ); |
|
2707 } |
|
2708 // No changes to clip(s) or no clip(s) in time line. |
|
2709 else |
|
2710 { |
|
2711 // Remove all clips from edit view (for future use). |
|
2712 iMovie->Reset(); |
|
2713 |
|
2714 iMovieSavedFlag = ETrue; // Movie is saved. |
|
2715 iMovieFirstAddFlag = ETrue; // True for the next edit process. |
|
2716 AppUi()->HandleCommandL( aCommand ); |
|
2717 } |
|
2718 |
|
2719 break; |
|
2720 } |
|
2721 // |
|
2722 // Options->Help |
|
2723 // |
|
2724 case EVeiCmdEditVideoViewHelp: |
|
2725 { |
|
2726 LOG( KVideoEditorLogFile, "\tEVeiCmdEditVideoViewHelp" ); |
|
2727 // CS Help launching is handled in Video Editor's AppUi. |
|
2728 AppUi()->HandleCommandL( EVeiCmdEditVideoViewHelp ); |
|
2729 break; |
|
2730 } |
|
2731 /** |
|
2732 * Exit |
|
2733 */ |
|
2734 case EEikCmdExit: |
|
2735 { |
|
2736 LOG( KVideoEditorLogFile, "\tEEikCmdExit" ); |
|
2737 // Edited movie is not saved yet and there are video or audio clip(s) at the time line. |
|
2738 if ( !iMovieSavedFlag && ( iMovie->VideoClipCount() > 0 || iMovie->AudioClipCount() > 0 )) |
|
2739 { |
|
2740 HBufC* stringholder; // String holding the text shown in dialog. |
|
2741 |
|
2742 CAknQueryDialog* dlg; // Save confirmation dialog. |
|
2743 TInt queryok; // Query result. |
|
2744 |
|
2745 stringholder = StringLoader::LoadLC( R_VEI_CONFIRM_EXIT_SAVE, iEikonEnv ); |
|
2746 |
|
2747 dlg = new( ELeave )CAknQueryDialog( *stringholder, CAknQueryDialog::ENoTone ); |
|
2748 queryok = dlg->ExecuteLD( R_VEI_CONFIRMATION_QUERY ); |
|
2749 |
|
2750 if ( !queryok ) |
|
2751 { |
|
2752 iMovie->Reset(); |
|
2753 AppUi()->HandleCommandL( aCommand ); |
|
2754 } |
|
2755 else |
|
2756 { |
|
2757 SaveL( EProcessingMovieSaveThenQuit ); |
|
2758 iWaitMode = EProcessingMovieSaveThenQuit; |
|
2759 } |
|
2760 |
|
2761 CleanupStack::PopAndDestroy( stringholder ); |
|
2762 } |
|
2763 else |
|
2764 // No changes to clip(s) or no clip(s) in time line. |
|
2765 { |
|
2766 iMovie->Reset(); // Remove all clips from edit view. |
|
2767 AppUi()->HandleCommandL( aCommand ); // Let appUi handle the exit. |
|
2768 } |
|
2769 break; |
|
2770 } |
|
2771 default: |
|
2772 { |
|
2773 LOG( KVideoEditorLogFile, "\tdefault" ); |
|
2774 AppUi()->HandleCommandL( aCommand ); |
|
2775 break; |
|
2776 } |
|
2777 } |
|
2778 |
|
2779 LOG( KVideoEditorLogFile, "CVeiEditVideoView::HandleCommandL: Out" ); |
|
2780 } |
|
2781 |
|
2782 void CVeiEditVideoView::HandleResourceChange( TInt aType ) |
|
2783 { |
|
2784 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::HandleResourceChange() In, aType:%d", aType ); |
|
2785 |
|
2786 if ( KAknsMessageSkinChange == aType ) |
|
2787 { |
|
2788 // Handle skin change in the navi label controls - they do not receive |
|
2789 // it automatically since they are not in the control stack |
|
2790 iPreviewLabel->DecoratedControl()->HandleResourceChange( aType ); |
|
2791 iEditLabel->DecoratedControl()->HandleResourceChange( aType ); |
|
2792 iVolumeNavi->DecoratedControl()->HandleResourceChange( aType ); |
|
2793 iMoveLabel->DecoratedControl()->HandleResourceChange( aType ); |
|
2794 } |
|
2795 |
|
2796 LOG( KVideoEditorLogFile, "CVeiEditVideoView::HandleResourceChange() Out" ); |
|
2797 } |
|
2798 |
|
2799 void CVeiEditVideoView::SetEditorState( TEditorState aState ) |
|
2800 { |
|
2801 LOGFMT3( KVideoEditorLogFile, "CVeiEditVideoView::SetEditorState: in, aState:%d, iEditorState:%d, iFullScreenSelected:%d", aState, iEditorState, iFullScreenSelected ); |
|
2802 |
|
2803 CAknTitlePane* titlePane; |
|
2804 CEikStatusPane* statusPane; |
|
2805 TResourceReader reader1; |
|
2806 |
|
2807 iEditorState = aState; |
|
2808 |
|
2809 switch ( aState ) |
|
2810 { |
|
2811 case EPreview: |
|
2812 /* |
|
2813 if ( iFullScreenSelected ) |
|
2814 { |
|
2815 // @: this need more elaborating |
|
2816 // problem is: after large preview signal and battery pane are black in some phone models |
|
2817 //statusPane = ( ( CAknAppUi* )iEikonEnv->EikAppUi() )->StatusPane(); |
|
2818 //statusPane ->MakeVisible( EFalse ); |
|
2819 Cba()->MakeVisible( EFalse ); |
|
2820 Cba()->DrawDeferred(); |
|
2821 } |
|
2822 else |
|
2823 { |
|
2824 iEditorState = EQuickPreview; |
|
2825 statusPane = ( ( CAknAppUi* )iEikonEnv->EikAppUi() )->StatusPane(); |
|
2826 |
|
2827 titlePane = (CAknTitlePane*) statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ); |
|
2828 iCoeEnv->CreateResourceReaderLC( reader1, R_VEI_PREVIEW_VIEW_TITLE_NAME ); |
|
2829 titlePane->SetFromResourceL( reader1 ); |
|
2830 CleanupStack::PopAndDestroy(); //reader1 |
|
2831 |
|
2832 LOG(KVideoEditorLogFile, "CVeiEditVideoView::SetEditorState, 1, setting R_VEI_SOFTKEYS_PREVIEW_PAUSE_BACK"); |
|
2833 Cba()->SetCommandSetL( R_VEI_SOFTKEYS_PREVIEW_PAUSE_BACK ); |
|
2834 Cba()->DrawDeferred(); |
|
2835 } |
|
2836 */ |
|
2837 Cba()->MakeVisible( EFalse ); |
|
2838 Cba()->DrawDeferred(); |
|
2839 break; |
|
2840 case EQuickPreview: |
|
2841 { |
|
2842 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::SetEditorState: 2, iContainer->PreviewState():%d", iContainer->PreviewState()); |
|
2843 statusPane = (( CAknAppUi* )iEikonEnv->EikAppUi())->StatusPane(); |
|
2844 |
|
2845 titlePane = ( CAknTitlePane* )statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle )); |
|
2846 iCoeEnv->CreateResourceReaderLC( reader1, R_VEI_PREVIEW_VIEW_TITLE_NAME ); |
|
2847 titlePane->SetFromResourceL( reader1 ); |
|
2848 CleanupStack::PopAndDestroy(); //reader1 |
|
2849 |
|
2850 if (( iContainer->PreviewState() == CVeiEditVideoContainer::EStatePaused ) || |
|
2851 ( iContainer->PreviewState() == CVeiEditVideoContainer::EStateStopped )) |
|
2852 { |
|
2853 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SetEditorState, 3, setting R_VEI_SOFTKEYS_PREVIEW_PLAY_BACK" ); |
|
2854 Cba()->SetCommandSetL( R_VEI_SOFTKEYS_PREVIEW_PLAY_BACK ); |
|
2855 } |
|
2856 else if (( iContainer->PreviewState() == CVeiEditVideoContainer::EStateOpening ) || |
|
2857 ( iContainer->PreviewState() == CVeiEditVideoContainer::EStateGettingFrame ) || |
|
2858 ( iContainer->PreviewState() == CVeiEditVideoContainer::EStateBuffering )) |
|
2859 { |
|
2860 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SetEditorState, 4, setting R_AVKON_SOFTKEYS_EMPTY" ); |
|
2861 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_EMPTY ); |
|
2862 } |
|
2863 else |
|
2864 { |
|
2865 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SetEditorState, 5, setting R_VEI_SOFTKEYS_PREVIEW_PAUSE_BACK" ); |
|
2866 Cba()->SetCommandSetL( R_VEI_SOFTKEYS_PREVIEW_PAUSE_BACK ); |
|
2867 } |
|
2868 Cba()->DrawDeferred(); |
|
2869 break; |
|
2870 } |
|
2871 case EEdit: |
|
2872 iContainer->SetRect( AppUi()->ClientRect()); |
|
2873 statusPane = (( CAknAppUi* )iEikonEnv->EikAppUi())->StatusPane(); |
|
2874 // @: this needs more elaborating |
|
2875 //statusPane ->MakeVisible( ETrue ); |
|
2876 |
|
2877 titlePane = ( CAknTitlePane* )statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle )); |
|
2878 iCoeEnv->CreateResourceReaderLC( reader1, R_VEI_EDIT_VIDEO_VIEW_TITLE_NAME ); |
|
2879 titlePane->SetFromResourceL( reader1 ); |
|
2880 CleanupStack::PopAndDestroy(); //reader1 |
|
2881 |
|
2882 Cba()->MakeVisible( ETrue ); |
|
2883 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); |
|
2884 Cba()->DrawDeferred(); |
|
2885 break; |
|
2886 |
|
2887 case EMixAudio: |
|
2888 iContainer->SetRect( AppUi()->ClientRect()); |
|
2889 statusPane = (( CAknAppUi* )iEikonEnv->EikAppUi())->StatusPane(); |
|
2890 |
|
2891 titlePane = ( CAknTitlePane* )statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle )); |
|
2892 iCoeEnv->CreateResourceReaderLC( reader1, R_VEI_AUDIO_MIX_VIEW_TITLE_NAME ); |
|
2893 titlePane->SetFromResourceL( reader1 ); |
|
2894 CleanupStack::PopAndDestroy(); //reader1 |
|
2895 |
|
2896 Cba()->MakeVisible( ETrue ); |
|
2897 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_DONE ); |
|
2898 Cba()->DrawDeferred(); |
|
2899 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeMixingAudio ); |
|
2900 |
|
2901 break; |
|
2902 |
|
2903 case EAdjustVolume: |
|
2904 iContainer->SetRect( AppUi()->ClientRect()); |
|
2905 statusPane = (( CAknAppUi* )iEikonEnv->EikAppUi())->StatusPane(); |
|
2906 |
|
2907 titlePane = ( CAknTitlePane* )statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle )); |
|
2908 iCoeEnv->CreateResourceReaderLC( reader1, R_VEI_ADJUST_VOLUME_VIEW_TITLE_NAME ); |
|
2909 titlePane->SetFromResourceL( reader1 ); |
|
2910 CleanupStack::PopAndDestroy(); //reader1 |
|
2911 |
|
2912 Cba()->MakeVisible( ETrue ); |
|
2913 //Cba()->SetCommandSetL(R_AVKON_SOFTKEYS_OPTIONS_DONE); |
|
2914 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OK_CANCEL ); |
|
2915 Cba()->DrawDeferred(); |
|
2916 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeAdjustVolume ); |
|
2917 |
|
2918 break; |
|
2919 |
|
2920 |
|
2921 default: |
|
2922 { |
|
2923 break; |
|
2924 } |
|
2925 } |
|
2926 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SetEditorState: Out" ); |
|
2927 } |
|
2928 |
|
2929 |
|
2930 void CVeiEditVideoView::SendMovieL() |
|
2931 { |
|
2932 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SendMovieL() -- SENDING" ); |
|
2933 |
|
2934 TEntry fileinfo; |
|
2935 |
|
2936 RFs& fs = iEikonEnv->FsSession(); |
|
2937 // Rename movie from xxxx.$$$ to defaultfilename from settingsview. |
|
2938 // looks better in attachment list.. |
|
2939 |
|
2940 // Get default movie name from settings view |
|
2941 |
|
2942 TPtr temppeet = iTempFile->Des(); |
|
2943 |
|
2944 TParse parse; |
|
2945 parse.Set( iMovieSaveSettings.DefaultVideoName(), &temppeet, NULL ); |
|
2946 |
|
2947 TFileName orgPathAndName = parse.FullName(); |
|
2948 |
|
2949 TVedVideoFormat movieQuality = iMovie->Format(); |
|
2950 if ( movieQuality == EVedVideoFormatMP4 ) |
|
2951 { |
|
2952 orgPathAndName.Replace( orgPathAndName.Length() - 4, 4, KExtMp4 ); |
|
2953 } |
|
2954 else |
|
2955 { |
|
2956 orgPathAndName.Replace( orgPathAndName.Length() - 4, 4, KExt3gp ); |
|
2957 } |
|
2958 |
|
2959 fs.Replace( *iTempFile, orgPathAndName ); |
|
2960 iTempFile->Des() = orgPathAndName; |
|
2961 |
|
2962 fs.Entry( *iTempFile, fileinfo ); |
|
2963 |
|
2964 DEBUGLOG_ARG( TInt tempFileSize = fileinfo.iSize / 1024 ); |
|
2965 LOGFMT3( KVideoEditorLogFile, "CVeiEditVideoView::SendMovieL() 1, iWaitMode:%d, tempFileSize:%d, ValidateServiceL:%d", iWaitMode, tempFileSize, iSendAppUi.ValidateServiceL( iGivenSendCommand, TSendingCapabilities( 0, tempFileSize, TSendingCapabilities::ESupportsAttachments ))); |
|
2966 |
|
2967 if ( EProcessingMovieSend == iWaitMode |
|
2968 /*&& (iSendAppUi.ValidateServiceL( |
|
2969 iGivenSendCommand, |
|
2970 TSendingCapabilities( 0, |
|
2971 tempFileSize, |
|
2972 TSendingCapabilities::ESupportsAttachments ) ) ) */ ) |
|
2973 { |
|
2974 RFs shareFServer; |
|
2975 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SendMovieL: shareFServer connect." ); |
|
2976 |
|
2977 User::LeaveIfError( shareFServer.Connect()); |
|
2978 shareFServer.ShareProtected(); |
|
2979 CleanupClosePushL < RFs > ( shareFServer ); |
|
2980 |
|
2981 RFile openFileHandle; |
|
2982 |
|
2983 TInt err = openFileHandle.Open( shareFServer, * iTempFile, EFileRead | EFileShareReadersOnly ); |
|
2984 if ( KErrNone != err ) |
|
2985 { |
|
2986 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::SendMovieL 2: Could not open file %S with EFileShareReadersOnly. Trying EFileShareAny", iTempFile ); |
|
2987 User::LeaveIfError( openFileHandle.Open( shareFServer, * iTempFile, EFileRead | EFileShareAny )); |
|
2988 } |
|
2989 |
|
2990 CMessageData* messageData = CMessageData::NewLC(); |
|
2991 messageData->AppendAttachmentHandleL( openFileHandle ); |
|
2992 |
|
2993 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SendMovieL() 3" ); |
|
2994 |
|
2995 iSendAppUi.CreateAndSendMessageL( iGivenSendCommand, messageData, KNullUid, EFalse ); |
|
2996 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SendMovieL() 4" ); |
|
2997 CleanupStack::PopAndDestroy( messageData ); |
|
2998 |
|
2999 CleanupStack::PopAndDestroy( &shareFServer ); // shareFServer.Close(); |
|
3000 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SendMovieL 5: shareFServer closed." ); |
|
3001 } |
|
3002 |
|
3003 DoUpdateEditNaviLabelL(); |
|
3004 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SendMovieL() Out" ); |
|
3005 } |
|
3006 |
|
3007 |
|
3008 void CVeiEditVideoView::StartTempFileProcessingL() |
|
3009 { |
|
3010 LOG( KVideoEditorLogFile, "CVeiEditVideoView::StartTempFileProcessingL: In" ); |
|
3011 |
|
3012 RFs& fs = iEikonEnv->FsSession(); |
|
3013 |
|
3014 TBool fileExists( ETrue ); |
|
3015 if ( iTempFile ) |
|
3016 { |
|
3017 fileExists = BaflUtils::FileExists( fs, * iTempFile ); |
|
3018 } |
|
3019 |
|
3020 /* to save from unnecessary processing before preview |
|
3021 prerequisites: |
|
3022 -user selected preview |
|
3023 -no movie modifying actions taken by user before preview (iUpdateTemp is EFalse) |
|
3024 */ |
|
3025 if ( EProcessingMoviePreview == iWaitMode && !iUpdateTemp && !iTempFile && 1 == iMovie->VideoClipCount()) |
|
3026 { |
|
3027 if ( iFullScreenSelected ) |
|
3028 { |
|
3029 iContainer->SetBlackScreen( ETrue ); |
|
3030 iContainer->SetRect( AppUi()->ApplicationRect()); |
|
3031 } |
|
3032 |
|
3033 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModePreview ); |
|
3034 iContainer->PlayVideoFileL( iMovie->VideoClipInfo( 0 )->DescriptiveName(), iFullScreenSelected ); |
|
3035 } |
|
3036 else if ( EProcessingMovieTrimMms == iWaitMode && !iUpdateTemp && !iTempFile && 1 == iMovie->VideoClipCount() && !FitsToMmsL()) |
|
3037 { |
|
3038 /* |
|
3039 Read documentation of FitsToMmsL() in the header file |
|
3040 */ |
|
3041 TBuf8 < KMaxFileName > conv8Filename; |
|
3042 CnvUtfConverter::ConvertFromUnicodeToUtf8( conv8Filename, iMovie->VideoClipInfo( 0 )->DescriptiveName()); |
|
3043 iMovie->UnregisterMovieObserver( iContainer ); |
|
3044 iMovie->UnregisterMovieObserver( this ); |
|
3045 AppUi()->ActivateLocalViewL( TUid::Uid( EVeiTrimForMmsView ), TUid::Uid( 0 ), conv8Filename ); |
|
3046 } |
|
3047 else if ( iUpdateTemp || !fileExists || ( !iTempFile )) |
|
3048 { |
|
3049 LOG( KVideoEditorLogFile, "CVeiEditVideoView::StartTempFileProcessingL() 1, -- NEW TEMP" ); |
|
3050 |
|
3051 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_EMPTY ); |
|
3052 Cba()->DrawDeferred(); |
|
3053 if ( iTempFile && fileExists ) |
|
3054 { |
|
3055 User::LeaveIfError( fs.Delete( *iTempFile )); |
|
3056 delete iTempFile; |
|
3057 iTempFile = NULL; |
|
3058 } |
|
3059 |
|
3060 if ( !IsEnoughFreeSpaceToSaveL()) // modifies iMemoryInUse |
|
3061 { |
|
3062 return ; |
|
3063 } |
|
3064 |
|
3065 iTempFile = HBufC::NewL( KMaxFileName ); |
|
3066 iTempMaker->GenerateTempFileName( *iTempFile, iMemoryInUse, iMovie->Format()); |
|
3067 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::StartTempFileProcessingL 2, iTempFile:%S", iTempFile ); |
|
3068 |
|
3069 TVeiSettings movieSaveSettings; |
|
3070 |
|
3071 STATIC_CAST( CVeiAppUi* , AppUi())->ReadSettingsL( movieSaveSettings ); |
|
3072 |
|
3073 TInt settingsSaveQuality = movieSaveSettings.SaveQuality(); |
|
3074 CVedMovie::TVedMovieQuality saveQuality; |
|
3075 |
|
3076 switch ( settingsSaveQuality ) |
|
3077 { |
|
3078 case TVeiSettings::EMmsCompatible: |
|
3079 { |
|
3080 saveQuality = CVedMovie::EQualityMMSInteroperability; |
|
3081 break; |
|
3082 } |
|
3083 case TVeiSettings::EMedium: |
|
3084 { |
|
3085 saveQuality = CVedMovie::EQualityResolutionMedium; |
|
3086 break; |
|
3087 } |
|
3088 case TVeiSettings::EBest: |
|
3089 { |
|
3090 saveQuality = CVedMovie::EQualityResolutionHigh; |
|
3091 break; |
|
3092 } |
|
3093 case TVeiSettings::EAuto: default: |
|
3094 { |
|
3095 saveQuality = CVedMovie::EQualityAutomatic; |
|
3096 break; |
|
3097 } |
|
3098 } |
|
3099 |
|
3100 iMovie->SetQuality( saveQuality ); |
|
3101 iBackupSaveQuality = saveQuality; |
|
3102 |
|
3103 if ( EProcessingMovieTrimMms == iWaitMode ) |
|
3104 { |
|
3105 if ( saveQuality != CVedMovie::EQualityMMSInteroperability ) |
|
3106 { |
|
3107 iMovie->SetQuality( CVedMovie::EQualityMMSInteroperability ); |
|
3108 SetNewTempFileNeeded( ETrue ); |
|
3109 } |
|
3110 else |
|
3111 { |
|
3112 SetNewTempFileNeeded( EFalse ); |
|
3113 } |
|
3114 } |
|
3115 |
|
3116 TInt err; |
|
3117 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::StartTempFileProcessingL 3, calling iMovie->Process(%S)", iTempFile ); |
|
3118 TRAP( err, iMovie->ProcessL( *iTempFile, * this )); |
|
3119 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::StartTempFileProcessingL 4, err:%d", err ); |
|
3120 if ( err ) |
|
3121 { |
|
3122 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); |
|
3123 Cba()->DrawDeferred(); |
|
3124 ShowGlobalErrorNote( err ); |
|
3125 } |
|
3126 } |
|
3127 else |
|
3128 /* use old temp file*/ |
|
3129 { |
|
3130 LOG( KVideoEditorLogFile, "CVeiEditVideoView::StartTempFileProcessingL() 5, -- OLD TEMP" ); |
|
3131 if ( EProcessingMovieSend == iWaitMode ) |
|
3132 { |
|
3133 SendMovieL(); |
|
3134 } |
|
3135 else if ( EProcessingMovieTrimMms == iWaitMode ) |
|
3136 { |
|
3137 if ( iMovie->IsMovieMMSCompatible()) |
|
3138 { |
|
3139 LOG( KVideoEditorLogFile, "CVeiEditVideoView::StartTempFileProcessingL 6, MMS COMPATIBLE" ); |
|
3140 |
|
3141 TEntry entry; |
|
3142 User::LeaveIfError( fs.Entry( *iTempFile, entry )); |
|
3143 TInt tempFileSize = entry.iSize / 1024; |
|
3144 TInt maxMmsSize = STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->GetMaxMmsSize(); |
|
3145 |
|
3146 if ( tempFileSize < maxMmsSize ) |
|
3147 { |
|
3148 LOG( KVideoEditorLogFile, "CVeiEditVideoView::StartTempFileProcessingL() 7, -- MMS SIZE OK" ); |
|
3149 iWaitMode = EProcessingMovieSend; |
|
3150 SendMovieL(); |
|
3151 } |
|
3152 else |
|
3153 { |
|
3154 SetNewTempFileNeeded( EFalse ); |
|
3155 |
|
3156 LOG( KVideoEditorLogFile, "CVeiEditVideoView::StartTempFileProcessingL() 8, -- TRIM MMS" ); |
|
3157 |
|
3158 TBuf8 < KMaxFileName > conv8Filename; |
|
3159 CnvUtfConverter::ConvertFromUnicodeToUtf8( conv8Filename, * iTempFile ); |
|
3160 iMovie->UnregisterMovieObserver( iContainer ); |
|
3161 iMovie->UnregisterMovieObserver( this ); |
|
3162 AppUi()->ActivateLocalViewL( TUid::Uid( EVeiTrimForMmsView ), TUid::Uid( 0 ), conv8Filename ); |
|
3163 } |
|
3164 } |
|
3165 else |
|
3166 { |
|
3167 LOG( KVideoEditorLogFile, "CVeiEditVideoView::StartTempFileProcessingL() 9, -- NO MMS COMPATIBLE" ); |
|
3168 |
|
3169 TInt err; |
|
3170 if ( EProcessingMovieTrimMms == iWaitMode ) |
|
3171 { |
|
3172 iMovie->SetQuality( CVedMovie::EQualityMMSInteroperability ); |
|
3173 } |
|
3174 |
|
3175 TRAP( err, iMovie->ProcessL( *iTempFile, * this )); |
|
3176 |
|
3177 if ( err ) |
|
3178 { |
|
3179 ShowGlobalErrorNote( err ); |
|
3180 } |
|
3181 } |
|
3182 } |
|
3183 else if ( EProcessingMoviePreview == iWaitMode ) |
|
3184 { |
|
3185 if ( iFullScreenSelected ) |
|
3186 { |
|
3187 iContainer->SetBlackScreen( ETrue ); |
|
3188 iContainer->SetRect( AppUi()->ApplicationRect()); |
|
3189 } |
|
3190 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModePreview ); |
|
3191 iContainer->PlayVideoFileL( *iTempFile, iFullScreenSelected ); |
|
3192 } |
|
3193 else if (( EProcessingMovieSave == iWaitMode ) || ( EProcessingMovieSaveThenQuit == iWaitMode )) |
|
3194 { |
|
3195 CFileMan* fileman = CFileMan::NewL( fs ); |
|
3196 CleanupStack::PushL( fileman ); |
|
3197 |
|
3198 if ( iTempFile->Left( 1 ) == iSaveToFileName->Left( 1 )) |
|
3199 { |
|
3200 fileman->Rename( *iTempFile, * iSaveToFileName ); |
|
3201 } |
|
3202 else |
|
3203 { |
|
3204 fileman->Move( *iTempFile, * iSaveToFileName ); |
|
3205 } |
|
3206 |
|
3207 CleanupStack::PopAndDestroy( fileman ); |
|
3208 |
|
3209 HBufC* stringholder = StringLoader::LoadL( R_VEI_NOTE_VIDEO_SAVED, iEikonEnv ); |
|
3210 CleanupStack::PushL( stringholder ); |
|
3211 iWaitMode = ENotWaiting; |
|
3212 ShowInformationNoteL( *stringholder ); |
|
3213 iMovieSavedFlag = ETrue; |
|
3214 CleanupStack::PopAndDestroy( stringholder); |
|
3215 |
|
3216 UpdateMediaGalleryL(); |
|
3217 } |
|
3218 } |
|
3219 LOG( KVideoEditorLogFile, "CVeiEditVideoView::StartTempFileProcessingL: Out" ); |
|
3220 } |
|
3221 |
|
3222 void CVeiEditVideoView::InsertNewAudio() |
|
3223 { |
|
3224 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_EMPTY ); |
|
3225 Cba()->DrawDeferred(); |
|
3226 |
|
3227 iContainer->SetRecordedAudio( ETrue ); |
|
3228 |
|
3229 TInt64 startTimeInt = 0; |
|
3230 TInt64 durationInt = 1000000; |
|
3231 TInt currIndex( 0 ); |
|
3232 |
|
3233 if ((( iContainer->CursorLocation() == VideoEditor::ECursorOnAudio ) || |
|
3234 ( iContainer->CursorLocation() == VideoEditor::ECursorOnEmptyAudioTrack )) && |
|
3235 ( iMovie->AudioClipCount() > 0 )) |
|
3236 { |
|
3237 currIndex = iContainer->CurrentIndex() + 1; |
|
3238 startTimeInt = iMovie->AudioClipEndTime( iContainer->CurrentIndex()).Int64(); |
|
3239 } |
|
3240 else |
|
3241 { |
|
3242 currIndex = iMovie->AudioClipCount() - 1; |
|
3243 if ( currIndex >= 0 ) |
|
3244 { |
|
3245 startTimeInt = iMovie->AudioClipEndTime( currIndex ).Int64(); |
|
3246 } |
|
3247 else |
|
3248 { |
|
3249 currIndex = 0; |
|
3250 } |
|
3251 } |
|
3252 |
|
3253 while ( currIndex < iMovie->AudioClipCount()) |
|
3254 { |
|
3255 // safety margin: it is not possible to insert new audio if there is less than 1s between clips |
|
3256 TInt64 adjustedClipStartTimeInt = iMovie->AudioClipStartTime( currIndex ).Int64() - 1000000; |
|
3257 |
|
3258 if ( startTimeInt > adjustedClipStartTimeInt ) |
|
3259 { |
|
3260 startTimeInt = iMovie->AudioClipEndTime( currIndex ).Int64(); |
|
3261 currIndex++; |
|
3262 } |
|
3263 else |
|
3264 { |
|
3265 break; |
|
3266 } |
|
3267 } |
|
3268 |
|
3269 if ( currIndex < iMovie->AudioClipCount()) |
|
3270 { |
|
3271 TInt64 endTimeInt = startTimeInt + durationInt; |
|
3272 TInt64 nextStartTimeInt = iMovie->AudioClipStartTime( currIndex ).Int64(); |
|
3273 |
|
3274 if ( endTimeInt > nextStartTimeInt ) |
|
3275 { |
|
3276 durationInt = nextStartTimeInt - startTimeInt; |
|
3277 } |
|
3278 } |
|
3279 |
|
3280 iContainer->SetRecordedAudioStartTime( TTimeIntervalMicroSeconds( startTimeInt )); |
|
3281 iContainer->SetRecordedAudioDuration( TTimeIntervalMicroSeconds( durationInt )); |
|
3282 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeRecordingSetStart ); |
|
3283 iContainer->SetCursorLocation( VideoEditor::ECursorOnAudio ); |
|
3284 |
|
3285 UpdateEditNaviLabel(); |
|
3286 |
|
3287 /* Create temp file. */ |
|
3288 if ( iTempRecordedAudio ) |
|
3289 { |
|
3290 delete iTempRecordedAudio; |
|
3291 iTempRecordedAudio = NULL; |
|
3292 } |
|
3293 |
|
3294 iTempRecordedAudio = HBufC::NewL( KMaxFileName ); |
|
3295 iTempMaker->GenerateTempFileName( *iTempRecordedAudio, iMemoryInUse, iMovie->Format(), ETrue ); |
|
3296 |
|
3297 /* Open the file, this is asynchronous so we'll come to our callback. */ |
|
3298 iRecorder->OpenFileL( *iTempRecordedAudio ); |
|
3299 } |
|
3300 |
|
3301 TBool CVeiEditVideoView::IsEnoughFreeSpaceToSaveL( TInt aBytesToAdd )const |
|
3302 { |
|
3303 LOG( KVideoEditorLogFile, "CVeiEditVideoView::IsEnoughFreeSpaceToSaveL: in" ); |
|
3304 RFs& fs = iEikonEnv->FsSession(); |
|
3305 |
|
3306 TBool spaceBelowCriticalLevel( EFalse ); |
|
3307 |
|
3308 TInt sizeEstimate = iMovie->GetSizeEstimateL(); |
|
3309 sizeEstimate += aBytesToAdd; |
|
3310 |
|
3311 if ( iEditorState == EQuickPreview ) |
|
3312 { |
|
3313 TInt snapShotSize = iContainer->SnapshotSize(); |
|
3314 if ( snapShotSize != 0 ) |
|
3315 { |
|
3316 sizeEstimate = snapShotSize; |
|
3317 } |
|
3318 } |
|
3319 |
|
3320 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::IsEnoughFreeSpaceToSaveL: 2, needed space: %d", sizeEstimate ); |
|
3321 |
|
3322 if ( iMemoryInUse == CAknMemorySelectionDialog::EPhoneMemory ) |
|
3323 { |
|
3324 LOG( KVideoEditorLogFile, "CVeiEditVideoView::IsEnoughFreeSpaceToSaveL: " ); |
|
3325 spaceBelowCriticalLevel = SysUtil::DiskSpaceBelowCriticalLevelL( &fs, sizeEstimate, EDriveC ); |
|
3326 } |
|
3327 else |
|
3328 { |
|
3329 LOG( KVideoEditorLogFile, "\tMmc selected" ); |
|
3330 |
|
3331 spaceBelowCriticalLevel = SysUtil::MMCSpaceBelowCriticalLevelL( &fs, sizeEstimate ); |
|
3332 } |
|
3333 |
|
3334 if ( spaceBelowCriticalLevel ) |
|
3335 { |
|
3336 LOG( KVideoEditorLogFile, "CVeiEditVideoView::IsEnoughFreeSpaceToSaveL: 3, space is below critical level" ); |
|
3337 ShowErrorNote( R_VEI_MEMORY_RUNNING_OUT ); |
|
3338 } |
|
3339 |
|
3340 LOG( KVideoEditorLogFile, "CVeiEditVideoView::IsEnoughFreeSpaceToSaveL out" ); |
|
3341 |
|
3342 return !spaceBelowCriticalLevel; |
|
3343 } |
|
3344 |
|
3345 |
|
3346 TBool CVeiEditVideoView::IsEnoughFreeSpaceToSave2L( TInt aBytesToAdd )const |
|
3347 { |
|
3348 RFs& fs = iEikonEnv->FsSession(); |
|
3349 TBool spaceBelowCriticalLevel( EFalse ); |
|
3350 TInt sizeEstimate = iMovie->GetSizeEstimateL(); |
|
3351 sizeEstimate += aBytesToAdd; |
|
3352 |
|
3353 if ( iMemoryInUse == CAknMemorySelectionDialog::EPhoneMemory ) |
|
3354 { |
|
3355 spaceBelowCriticalLevel = SysUtil::DiskSpaceBelowCriticalLevelL( &fs, sizeEstimate, EDriveC ); |
|
3356 } |
|
3357 else |
|
3358 { |
|
3359 spaceBelowCriticalLevel = SysUtil::MMCSpaceBelowCriticalLevelL( &fs, sizeEstimate ); |
|
3360 } |
|
3361 |
|
3362 if ( !spaceBelowCriticalLevel ) |
|
3363 { |
|
3364 return ETrue; |
|
3365 } |
|
3366 else |
|
3367 { |
|
3368 return EFalse; |
|
3369 } |
|
3370 } |
|
3371 |
|
3372 TBool CVeiEditVideoView::FitsToMmsL() |
|
3373 { |
|
3374 /* |
|
3375 Read documentation of FitsToMmsL() in the header file |
|
3376 */ |
|
3377 LOG( KVideoEditorLogFile, "CVeiEditVideoView::FitsToMmsL() in" ); |
|
3378 TInt maxMmsSize = STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->GetMaxMmsSize(); |
|
3379 |
|
3380 CVedMovie::TVedMovieQuality origQuality = iMovie->Quality(); |
|
3381 iMovie->SetQuality( CVedMovie::EQualityMMSInteroperability ); |
|
3382 TInt videoTimeLineSize = iMovie->GetSizeEstimateL() / 1024; |
|
3383 iMovie->SetQuality( origQuality ); |
|
3384 LOG( KVideoEditorLogFile, "CVeiEditVideoView::FitsToMmsL() out" ); |
|
3385 videoTimeLineSize = videoTimeLineSize * 1.1; |
|
3386 return videoTimeLineSize < maxMmsSize; |
|
3387 } |
|
3388 |
|
3389 void CVeiEditVideoView::BrowseStartTransition( TBool aUpOrDown ) |
|
3390 { |
|
3391 TInt currentEffect; |
|
3392 TInt currentIndex = iContainer->CurrentIndex(); |
|
3393 |
|
3394 if ( currentIndex == 0 ) |
|
3395 { |
|
3396 currentEffect = iMovie->StartTransitionEffect(); |
|
3397 if ( aUpOrDown ) |
|
3398 { |
|
3399 if ( !( TVedStartTransitionEffect( currentEffect - 1 ) < EVedStartTransitionEffectNone )) |
|
3400 { |
|
3401 iMovie->SetStartTransitionEffect( TVedStartTransitionEffect( currentEffect - 1 )); |
|
3402 } |
|
3403 else |
|
3404 { |
|
3405 iMovie->SetStartTransitionEffect( TVedStartTransitionEffect( EVedStartTransitionEffectLast - 1 )); |
|
3406 } |
|
3407 } |
|
3408 else |
|
3409 { |
|
3410 if ( !( TVedStartTransitionEffect( currentEffect + 1 ) >= EVedStartTransitionEffectLast )) |
|
3411 { |
|
3412 iMovie->SetStartTransitionEffect( TVedStartTransitionEffect( currentEffect + 1 )); |
|
3413 } |
|
3414 else |
|
3415 { |
|
3416 iMovie->SetStartTransitionEffect( TVedStartTransitionEffect( EVedStartTransitionEffectNone )); |
|
3417 } |
|
3418 } |
|
3419 } |
|
3420 else if ( currentIndex < iMovie->VideoClipCount()) |
|
3421 { |
|
3422 currentEffect = iMovie->MiddleTransitionEffect( currentIndex - 1 ); |
|
3423 |
|
3424 if ( aUpOrDown ) |
|
3425 { |
|
3426 if ( !( TVedMiddleTransitionEffect( currentEffect - 1 ) < EVedMiddleTransitionEffectNone )) |
|
3427 { |
|
3428 iMovie->SetMiddleTransitionEffect( TVedMiddleTransitionEffect( currentEffect - 1 ), currentIndex - 1 ); |
|
3429 } |
|
3430 else |
|
3431 { |
|
3432 iMovie->SetMiddleTransitionEffect( TVedMiddleTransitionEffect( EVedMiddleTransitionEffectLast - 1 ), currentIndex - 1 ); |
|
3433 } |
|
3434 } |
|
3435 else |
|
3436 { |
|
3437 if ( !( TVedMiddleTransitionEffect( currentEffect + 1 ) >= EVedMiddleTransitionEffectLast )) |
|
3438 { |
|
3439 iMovie->SetMiddleTransitionEffect( TVedMiddleTransitionEffect( currentEffect + 1 ), currentIndex - 1 ); |
|
3440 } |
|
3441 else |
|
3442 { |
|
3443 iMovie->SetMiddleTransitionEffect( TVedMiddleTransitionEffect( EVedMiddleTransitionEffectNone ), currentIndex - 1 ); |
|
3444 } |
|
3445 } |
|
3446 } |
|
3447 else |
|
3448 { |
|
3449 currentEffect = iMovie->EndTransitionEffect(); |
|
3450 |
|
3451 if ( aUpOrDown ) |
|
3452 { |
|
3453 if ( !( TVedEndTransitionEffect( currentEffect - 1 ) < EVedEndTransitionEffectNone )) |
|
3454 { |
|
3455 iMovie->SetEndTransitionEffect( TVedEndTransitionEffect( currentEffect - 1 )); |
|
3456 } |
|
3457 else |
|
3458 { |
|
3459 iMovie->SetEndTransitionEffect( TVedEndTransitionEffect( EVedEndTransitionEffectLast - 1 )); |
|
3460 } |
|
3461 } |
|
3462 else |
|
3463 { |
|
3464 if ( !( TVedEndTransitionEffect( currentEffect + 1 ) >= EVedEndTransitionEffectLast )) |
|
3465 { |
|
3466 iMovie->SetEndTransitionEffect( TVedEndTransitionEffect( currentEffect + 1 )); |
|
3467 } |
|
3468 else |
|
3469 { |
|
3470 iMovie->SetEndTransitionEffect( TVedEndTransitionEffect( EVedEndTransitionEffectNone )); |
|
3471 } |
|
3472 } |
|
3473 } |
|
3474 |
|
3475 } |
|
3476 |
|
3477 void CVeiEditVideoView::ShowErrorNote( const TInt aResourceId, TInt /*aError*/ )const |
|
3478 { |
|
3479 CVeiErrorUI::ShowErrorNote( *iEikonEnv, aResourceId ); |
|
3480 } |
|
3481 |
|
3482 void CVeiEditVideoView::ShowGlobalErrorNote( const TInt aError )const |
|
3483 { |
|
3484 iErrorUI->ShowGlobalErrorNote( aError ); |
|
3485 } |
|
3486 |
|
3487 void CVeiEditVideoView::ShowInformationNoteL( const TDesC& aMessage )const |
|
3488 { |
|
3489 CAknInformationNote* note = new( ELeave )CAknInformationNote( ETrue ); |
|
3490 note->ExecuteLD( aMessage ); |
|
3491 } |
|
3492 |
|
3493 void CVeiEditVideoView::ShowVolumeLabelL( TInt aVolume ) |
|
3494 { |
|
3495 STATIC_CAST( CVeiTimeLabelNavi* , iPreviewLabel->DecoratedControl())->SetVolumeIconVisibilityL( ETrue ); |
|
3496 |
|
3497 if ( iVolumeHider && iVolumeHider->IsActive()) |
|
3498 { |
|
3499 iVolumeHider->Cancel(); |
|
3500 } |
|
3501 if ( aVolume == 0 ) |
|
3502 { |
|
3503 STATIC_CAST( CVeiTimeLabelNavi* , iPreviewLabel->DecoratedControl())->SetVolumeIconVisibilityL( EFalse ); |
|
3504 HideVolume(); |
|
3505 return ; |
|
3506 } |
|
3507 |
|
3508 iNaviPane->PushL( *iVolumeNavi ); |
|
3509 if ( !iVolumeHider ) |
|
3510 { |
|
3511 iVolumeHider = CPeriodic::NewL( CActive::EPriorityLow ); |
|
3512 } |
|
3513 iVolumeHider->Start( 1000000, 1000000, TCallBack( CVeiEditVideoView::HideVolumeCallbackL, this )); |
|
3514 |
|
3515 STATIC_CAST( CAknVolumeControl* , iVolumeNavi->DecoratedControl())->SetValue( aVolume ); |
|
3516 |
|
3517 if ( aVolume > KMinVolume + 1 ) |
|
3518 { |
|
3519 STATIC_CAST( CVeiTimeLabelNavi* , iPreviewLabel->DecoratedControl())->SetLeftArrowVisibilityL( ETrue ); |
|
3520 } |
|
3521 else |
|
3522 { |
|
3523 STATIC_CAST( CVeiTimeLabelNavi* , iPreviewLabel->DecoratedControl())->SetLeftArrowVisibilityL( EFalse ); |
|
3524 } |
|
3525 |
|
3526 if ( aVolume < KMaxVolume ) |
|
3527 { |
|
3528 STATIC_CAST( CVeiTimeLabelNavi* , iPreviewLabel->DecoratedControl())->SetRightArrowVisibilityL( ETrue ); |
|
3529 } |
|
3530 else |
|
3531 { |
|
3532 STATIC_CAST( CVeiTimeLabelNavi* , iPreviewLabel->DecoratedControl())->SetRightArrowVisibilityL( EFalse ); |
|
3533 } |
|
3534 |
|
3535 } |
|
3536 |
|
3537 void CVeiEditVideoView::RemoveCurrentClipL() |
|
3538 { |
|
3539 if ( !iContainer ) |
|
3540 { |
|
3541 return ; |
|
3542 } |
|
3543 TParse fp; |
|
3544 |
|
3545 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnAudio ) |
|
3546 { |
|
3547 if ( iMovie->AudioClipCount() == 0 ) |
|
3548 { |
|
3549 return ; |
|
3550 } |
|
3551 CVedAudioClipInfo* audioclipinfo = iMovie->AudioClipInfo( iContainer->CurrentIndex()); |
|
3552 fp.Set( audioclipinfo->FileName(), NULL, NULL ); |
|
3553 } |
|
3554 else |
|
3555 { |
|
3556 if ( iMovie->VideoClipCount() == 0 ) |
|
3557 { |
|
3558 return ; |
|
3559 } |
|
3560 |
|
3561 /* Get filename to remove query. */ |
|
3562 TBool isFile( iMovie->VideoClipInfo( iContainer->CurrentIndex())->Class() == EVedVideoClipClassFile ); |
|
3563 CVedVideoClipInfo* videoclipinfo = iMovie->VideoClipInfo( iContainer->CurrentIndex()); |
|
3564 |
|
3565 if ( isFile ) |
|
3566 { |
|
3567 fp.Set( videoclipinfo->FileName(), NULL, NULL ); |
|
3568 } |
|
3569 else |
|
3570 { |
|
3571 fp.Set( videoclipinfo->DescriptiveName(), NULL, NULL ); |
|
3572 } |
|
3573 } |
|
3574 |
|
3575 HBufC* stringholder = StringLoader::LoadL( R_VEI_REMOVE_CLIP_QUERY, fp.Name(), iEikonEnv ); |
|
3576 CleanupStack::PushL( stringholder ); |
|
3577 CAknQueryDialog* dlg = new( ELeave )CAknQueryDialog( *stringholder, CAknQueryDialog::ENoTone ); |
|
3578 TInt queryok = dlg->ExecuteLD( R_VEI_CONFIRMATION_QUERY ); |
|
3579 CleanupStack::PopAndDestroy( stringholder ); |
|
3580 |
|
3581 if ( queryok ) |
|
3582 { |
|
3583 TUint currentIndex = iContainer->GetAndDecrementCurrentIndex(); |
|
3584 |
|
3585 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnAudio ) |
|
3586 { |
|
3587 iMovie->RemoveAudioClip( currentIndex ); |
|
3588 } |
|
3589 else if ( iContainer->CursorLocation() == VideoEditor::ECursorOnClip ) |
|
3590 { |
|
3591 iMovie->RemoveVideoClip( currentIndex ); |
|
3592 } |
|
3593 else |
|
3594 { |
|
3595 ShowErrorNote( R_VEI_ERROR_NOTE ); |
|
3596 } |
|
3597 } |
|
3598 } |
|
3599 |
|
3600 |
|
3601 TInt CVeiEditVideoView::AddClipL( const TDesC& aFilename, TBool aStartNow ) |
|
3602 { |
|
3603 LOG( KVideoEditorLogFile, "CVeiEditVideoView::AddClipL: In" ); |
|
3604 |
|
3605 if ( !iContainer ) |
|
3606 { |
|
3607 iContainer = new( ELeave )CVeiEditVideoContainer( *iMovie, * this ); |
|
3608 iContainer->SetMopParent( this ); |
|
3609 iContainer->ConstructL( AppUi()->ClientRect()); |
|
3610 AppUi()->AddToStackL( *this, iContainer ); |
|
3611 } |
|
3612 |
|
3613 iMediaQueue->InsertMediaL( aFilename ); |
|
3614 |
|
3615 if ( aStartNow ) |
|
3616 { |
|
3617 iMediaQueue->StartProcessingL(); |
|
3618 } |
|
3619 |
|
3620 LOG( KVideoEditorLogFile, "CVeiEditVideoView::AddClipL: Out" ); |
|
3621 return KErrNone; |
|
3622 } |
|
3623 |
|
3624 |
|
3625 void CVeiEditVideoView::AddNext() |
|
3626 { |
|
3627 iMediaQueue->GetNext(); |
|
3628 } |
|
3629 |
|
3630 TBool CVeiEditVideoView::SaveL( TWaitMode aQuitAfterSaving ) |
|
3631 { |
|
3632 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SaveL: In" ); |
|
3633 RFs& fs = iEikonEnv->FsSession(); |
|
3634 |
|
3635 TParse file; |
|
3636 TFileName newname; |
|
3637 |
|
3638 // Get default movie name from settings view |
|
3639 CAknMemorySelectionDialog::TMemory memory( iMovieSaveSettings.MemoryInUse()); |
|
3640 |
|
3641 if ( memory == CAknMemorySelectionDialog::EPhoneMemory ) |
|
3642 { |
|
3643 newname = PathInfo::PhoneMemoryRootPath(); |
|
3644 } |
|
3645 else |
|
3646 { |
|
3647 newname = PathInfo::MemoryCardRootPath(); |
|
3648 } |
|
3649 |
|
3650 newname.Append( PathInfo::VideosPath()); |
|
3651 |
|
3652 TVedVideoFormat movieQuality = iMovie->Format(); |
|
3653 if ( movieQuality == EVedVideoFormatMP4 ) |
|
3654 { |
|
3655 newname.Append( KExtMp4 ); |
|
3656 } |
|
3657 else |
|
3658 { |
|
3659 newname.Append( KExt3gp ); |
|
3660 } |
|
3661 |
|
3662 file.Set( iMovieSaveSettings.DefaultVideoName(), &newname, NULL ); |
|
3663 |
|
3664 TInt error( KErrNone ); |
|
3665 error = fs.MkDirAll( file.DriveAndPath()); |
|
3666 |
|
3667 if (( error != KErrAlreadyExists ) && ( error != KErrNone )) |
|
3668 { |
|
3669 return EFalse; |
|
3670 } |
|
3671 |
|
3672 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SaveL: 2" ); |
|
3673 if ( IsEnoughFreeSpaceToSaveL()) |
|
3674 { |
|
3675 LOG( KVideoEditorLogFile, "CVeiEditVideoView::SaveL: 3" ); |
|
3676 //FileNameQuery |
|
3677 newname.Zero(); |
|
3678 newname.Append( file.FullName()); |
|
3679 |
|
3680 CApaApplication::GenerateFileName( fs, newname ); |
|
3681 CAknFileNamePromptDialog* dlg = CAknFileNamePromptDialog::NewL(); |
|
3682 CleanupStack::PushL( dlg ); |
|
3683 |
|
3684 HBufC* filenametitle = StringLoader::LoadLC( R_VEI_QUERY_FILE_NAME, iEikonEnv ); |
|
3685 |
|
3686 dlg->SetTitleL( *filenametitle ); |
|
3687 CleanupStack::PopAndDestroy( filenametitle ); |
|
3688 |
|
3689 TBool namegiven = dlg->ExecuteL( newname ); |
|
3690 CleanupStack::PopAndDestroy( dlg ); |
|
3691 |
|
3692 if ( namegiven ) |
|
3693 { |
|
3694 newname.Insert( 0, file.DriveAndPath()); |
|
3695 |
|
3696 file.Set( newname, NULL, NULL ); |
|
3697 |
|
3698 if ( BaflUtils::FileExists( fs, newname )) |
|
3699 { |
|
3700 TBool overWrite; |
|
3701 CAknQueryDialog* queryDlg; |
|
3702 |
|
3703 HBufC* overWriteConfirmationString; |
|
3704 overWriteConfirmationString = StringLoader::LoadLC( R_VEI_CONFIRM_OVERWRITE, file.Name(), iEikonEnv ); |
|
3705 queryDlg = new( ELeave )CAknQueryDialog( *overWriteConfirmationString, CAknQueryDialog::ENoTone ); |
|
3706 overWrite = queryDlg->ExecuteLD( R_VEI_CONFIRMATION_QUERY ); |
|
3707 |
|
3708 CleanupStack::PopAndDestroy( overWriteConfirmationString ); |
|
3709 if ( !overWrite ) |
|
3710 { |
|
3711 return EFalse; |
|
3712 } |
|
3713 } |
|
3714 |
|
3715 iWaitMode = aQuitAfterSaving; |
|
3716 |
|
3717 if ( iSaveToFileName ) |
|
3718 { |
|
3719 delete iSaveToFileName; |
|
3720 iSaveToFileName = NULL; |
|
3721 } |
|
3722 |
|
3723 iSaveToFileName = HBufC::NewL( newname.Length()); |
|
3724 *iSaveToFileName = newname; |
|
3725 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::SaveL: 4, iSaveToFileName:%S", iSaveToFileName ); |
|
3726 StartTempFileProcessingL(); |
|
3727 |
|
3728 return ETrue; |
|
3729 } |
|
3730 else |
|
3731 { |
|
3732 return EFalse; |
|
3733 } |
|
3734 } |
|
3735 |
|
3736 else |
|
3737 { |
|
3738 return EFalse; |
|
3739 } |
|
3740 } |
|
3741 |
|
3742 |
|
3743 // ---------------------------------------------------------------------------- |
|
3744 // CVeiEditVideoView::CheckMemoryCardAvailability() |
|
3745 // |
|
3746 // Checks the memory card availability if MMC is selected as save store in |
|
3747 // application settings. An information note is shown in following |
|
3748 // situations: |
|
3749 // - MMC not inserted |
|
3750 // - MMC corrupted (unformatted) |
|
3751 // [- MMC is read-only (not implemented)] |
|
3752 // |
|
3753 // If note is popped up, this function waits until it's dismissed. |
|
3754 // ---------------------------------------------------------------------------- |
|
3755 // |
|
3756 void CVeiEditVideoView::CheckMemoryCardAvailabilityL() |
|
3757 { |
|
3758 LOG( KVideoEditorLogFile, "CVeiEditVideoView::CheckMemoryCardAvailability(): in" ); |
|
3759 |
|
3760 // Read the video editor settings from ini file. |
|
3761 |
|
3762 iChangedFromMMCToPhoneMemory = EFalse; |
|
3763 |
|
3764 TVeiSettings settings; |
|
3765 STATIC_CAST( CVeiAppUi* , AppUi())->ReadSettingsL( settings ); |
|
3766 |
|
3767 CAknMemorySelectionDialog::TMemory memoryInUse( settings.MemoryInUse()); |
|
3768 |
|
3769 // Check the MMC accessibility only if MMC is used as saving store. |
|
3770 if ( memoryInUse == CAknMemorySelectionDialog::EMemoryCard ) |
|
3771 { |
|
3772 RFs& fs = iEikonEnv->FsSession(); |
|
3773 TDriveInfo driveInfo; |
|
3774 |
|
3775 User::LeaveIfError( fs.Drive( driveInfo, KMmcDrive )); |
|
3776 |
|
3777 // Media is not present (MMC card not inserted). |
|
3778 if ( driveInfo.iType == EMediaNotPresent ) |
|
3779 { |
|
3780 LOG( KVideoEditorLogFile, "CVeiEditVideoView::CheckMemoryCardAvailability(): no media" ); |
|
3781 iChangedFromMMCToPhoneMemory = ETrue; |
|
3782 |
|
3783 settings.MemoryInUse() = CAknMemorySelectionDialog::EPhoneMemory; |
|
3784 STATIC_CAST( CVeiAppUi* , AppUi())->WriteSettingsL( settings ); |
|
3785 } |
|
3786 // Media is present |
|
3787 else |
|
3788 { |
|
3789 LOG( KVideoEditorLogFile, "CVeiEditVideoView::CheckMemoryCardAvailability(): media present" ); |
|
3790 |
|
3791 TVolumeInfo volumeInfo; |
|
3792 TInt volumeErr = fs.Volume( volumeInfo, KMmcDrive ); |
|
3793 LOGFMT( KVideoEditorLogFile, "CEditVideoView::CheckMemoryCardAvailability() Volume(): %d", volumeErr ); |
|
3794 |
|
3795 // Show note if media is corrupted/unformatted. |
|
3796 if ( volumeErr == KErrCorrupt ) |
|
3797 { |
|
3798 HBufC* noteText = StringLoader::LoadLC( R_VED_MMC_NOT_INSERTED, iEikonEnv ); |
|
3799 CAknInformationNote* informationNote = new( ELeave )CAknInformationNote( ETrue ); |
|
3800 informationNote->ExecuteLD( *noteText ); |
|
3801 |
|
3802 CleanupStack::PopAndDestroy( noteText ); |
|
3803 |
|
3804 settings.MemoryInUse() = CAknMemorySelectionDialog::EPhoneMemory; |
|
3805 STATIC_CAST( CVeiAppUi* , AppUi())->WriteSettingsL( settings ); |
|
3806 } |
|
3807 } |
|
3808 } |
|
3809 |
|
3810 LOG( KVideoEditorLogFile, "CVeiEditVideoView::CheckMemoryCardAvailability(): out" ); |
|
3811 } |
|
3812 |
|
3813 void CVeiEditVideoView::UpdateEditNaviLabel()const |
|
3814 { |
|
3815 LOG( KVideoEditorLogFile, "CVeiEditVideoView::UpdateEditNaviLabel(): In" ); |
|
3816 if ( !iContainer ) |
|
3817 { |
|
3818 return ; |
|
3819 } |
|
3820 |
|
3821 TRAPD( err, DoUpdateEditNaviLabelL()); |
|
3822 |
|
3823 if ( err != KErrNone ) |
|
3824 { |
|
3825 ShowGlobalErrorNote( err ); |
|
3826 } |
|
3827 LOG( KVideoEditorLogFile, "CVeiEditVideoView::UpdateEditNaviLabel(): In" ); |
|
3828 } |
|
3829 |
|
3830 void CVeiEditVideoView::DoUpdateEditNaviLabelL()const |
|
3831 { |
|
3832 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DoUpdateEditNaviLabelL(): In" ); |
|
3833 |
|
3834 HBufC* buf; |
|
3835 |
|
3836 CAknNavigationDecorator* currentDecorator = iNaviPane->Top(); |
|
3837 |
|
3838 iNaviPane->Pop( iMoveLabel ); |
|
3839 iNaviPane->Pop( iPreviewLabel ); |
|
3840 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DoUpdateEditNaviLabelL(): navi labels popped" ); |
|
3841 |
|
3842 TBool leftArrowVisible = EFalse; |
|
3843 TBool rightArrowVisible = EFalse; |
|
3844 |
|
3845 TInt currentIndex = iContainer->CurrentIndex(); |
|
3846 |
|
3847 TInt test = iContainer->SelectionMode(); |
|
3848 |
|
3849 // Draw the time indicators to the navi pane in Small preview state. |
|
3850 // However, if the volume indicator is being show, do not draw the time label |
|
3851 if ( iContainer->SelectionMode() == CVeiEditVideoContainer::EModePreview && !iFullScreenSelected && !iVolumeHider ) |
|
3852 { |
|
3853 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DoUpdateEditNaviLabelL(): iContainer->SelectionMode() == CVeiEditVideoContainer::EModePreview && !iFullScreenSelected && !iVolumeHider" ); |
|
3854 |
|
3855 TTime elapsed( iContainer->PlaybackPositionL().Int64()); |
|
3856 TTime total( iContainer->TotalLength().Int64()); |
|
3857 |
|
3858 TBuf < 16 > elapsedBuf; |
|
3859 TBuf < 16 > totalBuf; |
|
3860 |
|
3861 HBufC* dateFormatString; |
|
3862 |
|
3863 // check if time is over 99:59 |
|
3864 if (( total.Int64() / 1000 ) < 3600000 ) |
|
3865 { |
|
3866 dateFormatString = iEikonEnv->AllocReadResourceLC( R_QTN_TIME_DURAT_MIN_SEC ); |
|
3867 } |
|
3868 else |
|
3869 { |
|
3870 dateFormatString = iEikonEnv->AllocReadResourceLC( R_QTN_TIME_DURAT_LONG ); |
|
3871 } |
|
3872 |
|
3873 elapsed.FormatL( elapsedBuf, * dateFormatString ); |
|
3874 total.FormatL( totalBuf, * dateFormatString ); |
|
3875 CleanupStack::PopAndDestroy( dateFormatString ); |
|
3876 |
|
3877 CDesCArrayFlat* strings = new CDesCArrayFlat( 2 ); |
|
3878 CleanupStack::PushL( strings ); |
|
3879 strings->AppendL( elapsedBuf ); |
|
3880 strings->AppendL( totalBuf ); |
|
3881 HBufC* stringholder = StringLoader::LoadL( R_VEI_NAVI_TIME, * strings, iEikonEnv ); |
|
3882 CleanupStack::PopAndDestroy( strings ); |
|
3883 CleanupStack::PushL( stringholder ); |
|
3884 |
|
3885 STATIC_CAST( CVeiTimeLabelNavi* , iPreviewLabel->DecoratedControl())->SetLabelL( stringholder->Des()); |
|
3886 |
|
3887 CleanupStack::PopAndDestroy( stringholder ); |
|
3888 |
|
3889 iNaviPane->PushL( *iPreviewLabel ); |
|
3890 } |
|
3891 |
|
3892 |
|
3893 else if ( iContainer->SelectionMode() == CVeiEditVideoContainer::EModeMove ) |
|
3894 { |
|
3895 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DoUpdateEditNaviLabelL(): iContainer->SelectionMode() == CVeiEditVideoContainer::EModeMove" ); |
|
3896 |
|
3897 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnAudio ) |
|
3898 { |
|
3899 buf = StringLoader::LoadLC( R_VEI_MOVE_AUDIO_NAVILABEL, iEikonEnv ); |
|
3900 |
|
3901 TTimeIntervalMicroSeconds startTime = iMovie->AudioClipStartTime( currentIndex ); |
|
3902 |
|
3903 if (( currentIndex == 0 ) && ( startTime > TTimeIntervalMicroSeconds( 0 ))) |
|
3904 { |
|
3905 leftArrowVisible = ETrue; |
|
3906 } |
|
3907 else |
|
3908 { |
|
3909 if ( currentIndex >= 1 ) |
|
3910 { |
|
3911 TTimeIntervalMicroSeconds prevEndTime = iMovie->AudioClipEndTime( currentIndex - 1 ); |
|
3912 TTimeIntervalMicroSeconds modifiedStartTime = TTimeIntervalMicroSeconds( startTime.Int64() - 100000 ); |
|
3913 |
|
3914 if ( modifiedStartTime > prevEndTime ) |
|
3915 { |
|
3916 leftArrowVisible = ETrue; |
|
3917 } |
|
3918 } |
|
3919 } |
|
3920 |
|
3921 if ( currentIndex < ( iMovie->AudioClipCount() - 1 )) |
|
3922 { |
|
3923 TTimeIntervalMicroSeconds modifiedEndTime = TTimeIntervalMicroSeconds( iMovie->AudioClipEndTime( currentIndex ).Int64() + 100000 ); |
|
3924 TTimeIntervalMicroSeconds nextStartTime = iMovie->AudioClipStartTime( currentIndex + 1 ); |
|
3925 if ( modifiedEndTime < nextStartTime ) |
|
3926 { |
|
3927 rightArrowVisible = ETrue; |
|
3928 } |
|
3929 } |
|
3930 |
|
3931 if ( currentIndex == iMovie->AudioClipCount() - 1 ) |
|
3932 { |
|
3933 rightArrowVisible = ETrue; |
|
3934 } |
|
3935 } |
|
3936 else |
|
3937 { |
|
3938 buf = StringLoader::LoadLC( R_VEI_MOVE_VIDEO_NAVILABEL, iEikonEnv ); |
|
3939 |
|
3940 if ( currentIndex > 0 ) |
|
3941 { |
|
3942 leftArrowVisible = ETrue; |
|
3943 } |
|
3944 if ( currentIndex < iMovie->VideoClipCount() - 1 ) |
|
3945 { |
|
3946 rightArrowVisible = ETrue; |
|
3947 } |
|
3948 } |
|
3949 |
|
3950 STATIC_CAST( CAknNaviLabel* , iMoveLabel->DecoratedControl())->SetTextL( *buf ); |
|
3951 |
|
3952 CleanupStack::PopAndDestroy( buf ); |
|
3953 |
|
3954 iMoveLabel->DrawNow(); |
|
3955 |
|
3956 iMoveLabel->MakeScrollButtonVisible( ETrue ); |
|
3957 iMoveLabel->SetScrollButtonDimmed( CAknNavigationDecorator::ELeftButton, !leftArrowVisible ); |
|
3958 iMoveLabel->SetScrollButtonDimmed( CAknNavigationDecorator::ERightButton, !rightArrowVisible ); |
|
3959 |
|
3960 iNaviPane->PushL( *iMoveLabel ); |
|
3961 } |
|
3962 else if ( iContainer->SelectionMode() == CVeiEditVideoContainer::EModeDuration ) |
|
3963 { |
|
3964 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DoUpdateEditNaviLabelL(): iContainer->SelectionMode() == CVeiEditVideoContainer::EModeDuration" ); |
|
3965 |
|
3966 buf = StringLoader::LoadLC( R_VEI_NAVI_PANE_DURATION, iEikonEnv ); |
|
3967 |
|
3968 STATIC_CAST( CAknNaviLabel* , iMoveLabel->DecoratedControl())->SetTextL( *buf ); |
|
3969 |
|
3970 CleanupStack::PopAndDestroy( buf ); |
|
3971 |
|
3972 iMoveLabel->DrawNow(); |
|
3973 |
|
3974 if ( currentDecorator ) |
|
3975 { |
|
3976 iMoveLabel->MakeScrollButtonVisible( ETrue ); |
|
3977 |
|
3978 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnAudio ) |
|
3979 { |
|
3980 TTimeIntervalMicroSeconds editedDuration = iMovie->AudioClipEditedDuration( currentIndex ); |
|
3981 TTimeIntervalMicroSeconds duration = iMovie->AudioClipInfo( currentIndex )->Duration(); |
|
3982 |
|
3983 if ( editedDuration > TTimeIntervalMicroSeconds( 100000 )) |
|
3984 { |
|
3985 leftArrowVisible = ETrue; |
|
3986 } |
|
3987 |
|
3988 if ( editedDuration < duration ) |
|
3989 { |
|
3990 rightArrowVisible = ETrue; |
|
3991 } |
|
3992 } |
|
3993 else |
|
3994 // Cursor on generated video clip |
|
3995 { |
|
3996 TTimeIntervalMicroSeconds duration = iMovie->VideoClipInfo( currentIndex )->Duration(); |
|
3997 if ( duration > TTimeIntervalMicroSeconds( 100000 )) |
|
3998 { |
|
3999 leftArrowVisible = ETrue; |
|
4000 } |
|
4001 rightArrowVisible = ETrue; |
|
4002 } |
|
4003 |
|
4004 iMoveLabel->SetScrollButtonDimmed( CAknNavigationDecorator::ELeftButton, !leftArrowVisible ); |
|
4005 iMoveLabel->SetScrollButtonDimmed( CAknNavigationDecorator::ERightButton, !rightArrowVisible ); |
|
4006 iNaviPane->PushL( *iMoveLabel ); |
|
4007 } |
|
4008 } |
|
4009 else |
|
4010 { |
|
4011 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DoUpdateEditNaviLabelL(): else-branch" ); |
|
4012 |
|
4013 TInt maxMmsSize = STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->GetMaxMmsSize(); |
|
4014 |
|
4015 CVedMovie::TVedMovieQuality origQuality = iMovie->Quality(); |
|
4016 iMovie->SetQuality( CVedMovie::EQualityMMSInteroperability ); |
|
4017 |
|
4018 TInt videoTimeLineSize = iMovie->GetSizeEstimateL() / 1024; |
|
4019 |
|
4020 iMovie->SetQuality( origQuality ); |
|
4021 |
|
4022 // Navipanes MMS icon control. |
|
4023 if ( videoTimeLineSize < maxMmsSize ) |
|
4024 { |
|
4025 STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->SetMmsAvailableL( ETrue ); |
|
4026 } |
|
4027 else |
|
4028 { |
|
4029 STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->SetMmsAvailableL( EFalse ); |
|
4030 } |
|
4031 |
|
4032 TInt size = iMovie->GetSizeEstimateL() / 1024; |
|
4033 /* If in recording state, show last audio clip end time+ recorded audio clip duration in navipane*/ |
|
4034 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::DoUpdateEditNaviLabelL: iMovie->GetSizeEstimateL() OK : %d", size ); |
|
4035 TTimeIntervalMicroSeconds audioEndTime( 0 ); |
|
4036 if ((( iContainer->SelectionMode() == CVeiEditVideoContainer::EModeRecording ) || |
|
4037 ( iContainer->SelectionMode() == CVeiEditVideoContainer::EModeRecordingPaused ))) |
|
4038 { |
|
4039 TInt audioCount = iMovie->AudioClipCount(); |
|
4040 /* check that cursor is on last audio clip */ |
|
4041 if (( audioCount > 0 ) && ( iContainer->CurrentIndex() == audioCount - 1 )) |
|
4042 { |
|
4043 audioEndTime = iMovie->AudioClipEndTime( audioCount - 1 ); |
|
4044 } |
|
4045 audioEndTime = audioEndTime.Int64() + iContainer->RecordedAudioDuration().Int64(); |
|
4046 /* |
|
4047 * Get recorded audio clip size and add it to engine size estimate |
|
4048 * The size won't match with size estimate that engine gives when recorded audio clip is added, |
|
4049 * |
|
4050 */ |
|
4051 RFs& fs = iEikonEnv->FsSession(); |
|
4052 TEntry entry; |
|
4053 |
|
4054 User::LeaveIfError( fs.Entry( *iTempRecordedAudio, entry )); |
|
4055 TInt recordedClipSize = entry.iSize / 1024; |
|
4056 size += recordedClipSize; |
|
4057 } |
|
4058 |
|
4059 if ( audioEndTime > iMovie->Duration()) |
|
4060 { |
|
4061 STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->SetDurationLabelL( audioEndTime.Int64()); |
|
4062 } |
|
4063 else |
|
4064 { |
|
4065 STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->SetDurationLabelL( iMovie->Duration().Int64()); |
|
4066 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::DoUpdateEditNaviLabelL: iMovie->Duration() OK : %Ld", iMovie->Duration().Int64()); |
|
4067 } |
|
4068 |
|
4069 // Video line size to navipane. |
|
4070 STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->SetSizeLabelL( size ); |
|
4071 |
|
4072 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::DoUpdateEditNaviLabelL: SetSizeLabelL(%d) OK", size ); |
|
4073 |
|
4074 // Get default memory from settings view |
|
4075 |
|
4076 if ( iMemoryInUse == CAknMemorySelectionDialog::EPhoneMemory ) |
|
4077 { |
|
4078 STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->SetMemoryInUseL( ETrue ); |
|
4079 } |
|
4080 else |
|
4081 { |
|
4082 STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->SetMemoryInUseL( EFalse ); |
|
4083 } |
|
4084 |
|
4085 if ( IsEnoughFreeSpaceToSave2L()) |
|
4086 { |
|
4087 STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->SetMemoryAvailableL( ETrue ); |
|
4088 } |
|
4089 else |
|
4090 { |
|
4091 STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->SetMemoryAvailableL( EFalse ); |
|
4092 } |
|
4093 if ( !currentDecorator ) |
|
4094 { |
|
4095 iNaviPane->PushL( *iEditLabel ); |
|
4096 } |
|
4097 } |
|
4098 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DoUpdateEditNaviLabelL(): Out" ); |
|
4099 } |
|
4100 |
|
4101 void CVeiEditVideoView::NotifyQueueProcessingStarted( MVeiQueueObserver::TProcessing aMode ) |
|
4102 { |
|
4103 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyQueueProcessingStarted: in" ); |
|
4104 |
|
4105 if ( iProgressNote ) |
|
4106 { |
|
4107 delete iProgressNote; |
|
4108 iProgressNote = NULL; |
|
4109 } |
|
4110 |
|
4111 if ( iWaitDialog ) |
|
4112 { |
|
4113 CancelWaitDialog(); |
|
4114 } |
|
4115 |
|
4116 HBufC* stringholder; |
|
4117 |
|
4118 switch ( aMode ) |
|
4119 { |
|
4120 case MVeiQueueObserver::EProcessingAudio: |
|
4121 |
|
4122 iProgressNote = new( ELeave )CAknProgressDialog( REINTERPRET_CAST( CEikDialog** , &iProgressNote ), ETrue ); |
|
4123 |
|
4124 iProgressNote->SetCallback( this ); |
|
4125 |
|
4126 iProgressNote->ExecuteDlgLD( R_VEI_PROGRESS_NOTE_WITH_CANCEL ); |
|
4127 |
|
4128 |
|
4129 stringholder = StringLoader::LoadLC( R_VEI_PROGRESS_NOTE_INSERTING_AUDIO, iEikonEnv ); |
|
4130 iProgressNote->SetTextL( *stringholder ); |
|
4131 CleanupStack::PopAndDestroy( stringholder ); |
|
4132 |
|
4133 iWaitMode = EOpeningAudioInfo; |
|
4134 iProgressNote->GetProgressInfoL()->SetFinalValue( 100 ); |
|
4135 break; |
|
4136 case MVeiQueueObserver::EProcessingVideo: |
|
4137 |
|
4138 iWaitDialog = new( ELeave )CAknWaitDialog( REINTERPRET_CAST( CEikDialog** , &iWaitDialog ), ETrue ); |
|
4139 iWaitDialog->ExecuteLD( R_VEI_WAIT_DIALOG_INSERTING_VIDEO ); |
|
4140 break; |
|
4141 default: |
|
4142 iProgressNote = new( ELeave )CAknProgressDialog( REINTERPRET_CAST( CEikDialog** , &iProgressNote ), ETrue ); |
|
4143 |
|
4144 iProgressNote->SetCallback( this ); |
|
4145 |
|
4146 iProgressNote->ExecuteDlgLD( R_VEI_PROGRESS_NOTE ); |
|
4147 UpdateInsertingProgressNoteL( 1 ); |
|
4148 iProgressNote->GetProgressInfoL()->SetFinalValue( 100 ); |
|
4149 break; |
|
4150 } |
|
4151 |
|
4152 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyQueueProcessingStarted: out" ); |
|
4153 } |
|
4154 |
|
4155 void CVeiEditVideoView::NotifyQueueProcessingProgressed( TInt aProcessedCount, TInt aPercentage ) |
|
4156 { |
|
4157 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyQueueProcessingProgressed: in" ); |
|
4158 if ( iProgressNote ) |
|
4159 { |
|
4160 UpdateInsertingProgressNoteL( aProcessedCount ); |
|
4161 iProgressNote->GetProgressInfoL()->SetAndDraw( aPercentage ); |
|
4162 } |
|
4163 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyQueueProcessingProgressed: out" ); |
|
4164 } |
|
4165 |
|
4166 TBool CVeiEditVideoView::NotifyQueueClipFailed( const TDesC& aFilename, TInt aError ) |
|
4167 { |
|
4168 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::NotifyQueueClipFailed: in, aError:%d", aError ); |
|
4169 |
|
4170 TBool result; |
|
4171 if ( aError == CVeiAddQueue::EInsertingSingleClip ) |
|
4172 { |
|
4173 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyQueueClipFailed: 1" ); |
|
4174 ShowErrorNote( R_VEI_VIDEO_FAILED ); |
|
4175 result = ETrue; |
|
4176 } |
|
4177 else |
|
4178 { |
|
4179 TBool continueProcessing; |
|
4180 CAknQueryDialog* dlg; |
|
4181 HBufC* failedContinueString; |
|
4182 |
|
4183 failedContinueString = StringLoader::LoadLC( R_VEI_WARNING_NOTE_INSERTING_FAILED, aFilename, iEikonEnv ); |
|
4184 dlg = new( ELeave )CAknQueryDialog( *failedContinueString, CAknQueryDialog::ENoTone ); |
|
4185 continueProcessing = dlg->ExecuteLD( R_VEI_CONFIRMATION_QUERY ); |
|
4186 |
|
4187 CleanupStack::PopAndDestroy( failedContinueString ); |
|
4188 |
|
4189 result = continueProcessing; |
|
4190 } |
|
4191 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyQueueClipFailed: out" ); |
|
4192 |
|
4193 return result; |
|
4194 } |
|
4195 |
|
4196 void CVeiEditVideoView::NotifyQueueEmpty( TInt /*aInserted*/, TInt DEBUGLOG_ARG( aFailed )) |
|
4197 { |
|
4198 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::NotifyQueueEmpty: in, aFailed:%d", aFailed ); |
|
4199 if ( iProgressNote ) |
|
4200 { |
|
4201 iProgressNote->GetProgressInfoL()->SetAndDraw( 100 ); |
|
4202 TRAP_IGNORE( iProgressNote->ProcessFinishedL()); |
|
4203 } |
|
4204 if ( iWaitDialog ) |
|
4205 { |
|
4206 CancelWaitDialog(); |
|
4207 } |
|
4208 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyQueueEmpty: out" ); |
|
4209 } |
|
4210 |
|
4211 |
|
4212 void CVeiEditVideoView::NotifyMovieProcessingStartedL( CVedMovie& /*aMovie*/ ) |
|
4213 { |
|
4214 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieProcessingStartedL: in" ); |
|
4215 |
|
4216 iPercentProcessed = 0; |
|
4217 |
|
4218 iProgressNote = new( ELeave )CAknProgressDialog( REINTERPRET_CAST( CEikDialog** , &iProgressNote ), ETrue ); |
|
4219 iProgressNote->SetCallback( this ); |
|
4220 iProgressNote->ExecuteDlgLD( R_VEI_PROGRESS_NOTE_WITH_CANCEL ); |
|
4221 |
|
4222 HBufC* stringholder; |
|
4223 |
|
4224 if (( EProcessingMovieSend == iWaitMode ) && ( KSenduiMtmBtUid == iGivenSendCommand )) |
|
4225 { |
|
4226 stringholder = StringLoader::LoadL( R_VEI_PROGRESS_NOTE_PROCESSING, iEikonEnv ); |
|
4227 } |
|
4228 else if ( EProcessingMovieSend == iWaitMode ) |
|
4229 { |
|
4230 stringholder = StringLoader::LoadL( R_VEI_PROGRESS_NOTE_SEND, iEikonEnv ); |
|
4231 } |
|
4232 else if ( EProcessingMoviePreview == iWaitMode ) |
|
4233 { |
|
4234 stringholder = StringLoader::LoadL( R_VEI_PROGRESS_NOTE_PROCESSING, iEikonEnv ); |
|
4235 } |
|
4236 else if ( EProcessingMovieTrimMms == iWaitMode ) |
|
4237 { |
|
4238 stringholder = StringLoader::LoadL( R_VEI_PROGRESS_NOTE_PROCESSING, iEikonEnv ); |
|
4239 } |
|
4240 else |
|
4241 { |
|
4242 stringholder = StringLoader::LoadL( R_VEI_PROGRESS_NOTE_SAVING, iEikonEnv ); |
|
4243 } |
|
4244 |
|
4245 CleanupStack::PushL( stringholder ); |
|
4246 |
|
4247 iProgressNote->SetTextL( *stringholder ); |
|
4248 CleanupStack::PopAndDestroy( stringholder ); |
|
4249 |
|
4250 iProgressNote->GetProgressInfoL()->SetFinalValue( 100 ); |
|
4251 |
|
4252 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieProcessingStartedL: out" ); |
|
4253 } |
|
4254 |
|
4255 void CVeiEditVideoView::NotifyMovieProcessingProgressed( CVedMovie& /*aMovie*/, TInt aPercentage ) |
|
4256 { |
|
4257 iPercentProcessed = aPercentage; |
|
4258 User::ResetInactivityTime(); |
|
4259 iProgressNote->GetProgressInfoL()->SetAndDraw( aPercentage ); |
|
4260 } |
|
4261 |
|
4262 void CVeiEditVideoView::NotifyMovieProcessingCompleted( CVedMovie& aMovie, TInt aError ) |
|
4263 { |
|
4264 LOGFMT2( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieProcessingCompleted: in, aError:%d, iPercentProcessed:%d", aError, iPercentProcessed ); |
|
4265 |
|
4266 aMovie.SetMovieSizeLimit( 0 ); // Movie size limit not in use |
|
4267 |
|
4268 if ( aError == KErrNone ) |
|
4269 { |
|
4270 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieProcessingCompleted: 2" ); |
|
4271 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); |
|
4272 Cba()->DrawDeferred(); |
|
4273 SetNewTempFileNeeded( EFalse ); |
|
4274 iProgressNote->GetProgressInfoL()->SetAndDraw( 100 ); |
|
4275 TRAP_IGNORE( iProgressNote->ProcessFinishedL()); |
|
4276 } |
|
4277 else |
|
4278 { |
|
4279 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieProcessingCompleted: 3" ); |
|
4280 if ( iProgressNote ) |
|
4281 { |
|
4282 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieProcessingCompleted: 4" ); |
|
4283 iWaitMode = EProcessingError; |
|
4284 TRAP_IGNORE( iProgressNote->GetProgressInfoL()->SetAndDraw( 100 )); |
|
4285 iErrorNmb = aError; |
|
4286 TRAP_IGNORE( iProgressNote->ProcessFinishedL()); |
|
4287 } |
|
4288 else |
|
4289 { |
|
4290 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieProcessingCompleted: 5" ); |
|
4291 if ( iTempFile ) |
|
4292 { |
|
4293 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieProcessingCompleted: 6" ); |
|
4294 RFs& fs = iEikonEnv->FsSession(); |
|
4295 |
|
4296 fs.Delete( *iTempFile ); |
|
4297 delete iTempFile; |
|
4298 iTempFile = NULL; |
|
4299 SetNewTempFileNeeded( ETrue ); |
|
4300 } |
|
4301 } |
|
4302 |
|
4303 // SetEditorState() must be called because of its side effects eventhough state has not changed, |
|
4304 // it sets CBAs. CBAs are set to empty before calling ProcessL() |
|
4305 if ( EMixAudio != iEditorState ) |
|
4306 { |
|
4307 SetEditorState( EEdit ); |
|
4308 } |
|
4309 else |
|
4310 { |
|
4311 SetEditorState( EMixAudio ); |
|
4312 } |
|
4313 |
|
4314 iContainer->SetBlackScreen( EFalse ); |
|
4315 iContainer->SetRect( AppUi()->ClientRect()); |
|
4316 } |
|
4317 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieProcessingCompleted: out" ); |
|
4318 } |
|
4319 |
|
4320 void CVeiEditVideoView::NotifyVideoClipAdded( CVedMovie& /*aMovie*/, TInt aIndex ) |
|
4321 { |
|
4322 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipAdded: in" ); |
|
4323 SetNewTempFileNeeded( ETrue ); |
|
4324 iMovieSavedFlag = EFalse; |
|
4325 |
|
4326 if ( iMovieFirstAddFlag ) |
|
4327 { |
|
4328 CVedVideoClipInfo* info = iMovie->VideoClipInfo( aIndex ); |
|
4329 |
|
4330 if ( EVedVideoClipClassGenerated != info->Class()) |
|
4331 { |
|
4332 SetNewTempFileNeeded( EFalse ); |
|
4333 iMovieSavedFlag = ETrue; |
|
4334 } |
|
4335 iMovieFirstAddFlag = EFalse; |
|
4336 } |
|
4337 |
|
4338 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipAdded: Completed" ); |
|
4339 |
|
4340 STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->SetState( CVeiEditVideoLabelNavi::EStateEditView ); |
|
4341 UpdateEditNaviLabel(); |
|
4342 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipAdded: out" ); |
|
4343 } |
|
4344 |
|
4345 void CVeiEditVideoView::NotifyVideoClipAddingFailed( CVedMovie& /*aMovie*/, TInt DEBUGLOG_ARG( aError )) |
|
4346 { |
|
4347 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipAddingFailed: in, aError:%d", aError ); |
|
4348 if ( iProgressNote ) |
|
4349 { |
|
4350 iProgressNote->GetProgressInfoL()->SetAndDraw( 100 ); |
|
4351 TRAP_IGNORE( iProgressNote->ProcessFinishedL()); |
|
4352 } |
|
4353 |
|
4354 if ( iWaitDialog ) |
|
4355 { |
|
4356 CancelWaitDialog(); |
|
4357 } |
|
4358 UpdateEditNaviLabel(); |
|
4359 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipAddingFailed: out" ); |
|
4360 } |
|
4361 |
|
4362 void CVeiEditVideoView::NotifyVideoClipRemoved( CVedMovie& /*aMovie*/, TInt /*aIndex*/ ) |
|
4363 { |
|
4364 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipRemoved: in" ); |
|
4365 SetNewTempFileNeeded( ETrue ); |
|
4366 iMovieSavedFlag = EFalse; |
|
4367 UpdateEditNaviLabel(); |
|
4368 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipRemoved: out" ); |
|
4369 } |
|
4370 |
|
4371 void CVeiEditVideoView::NotifyVideoClipIndicesChanged( CVedMovie& /*aMovie*/, TInt /*aOldIndex*/, TInt /*aNewIndex*/ ) |
|
4372 { |
|
4373 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipIndicesChanged: in" ); |
|
4374 iMovieSavedFlag = EFalse; |
|
4375 SetNewTempFileNeeded( ETrue ); |
|
4376 UpdateEditNaviLabel(); |
|
4377 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipIndicesChanged: out" ); |
|
4378 } |
|
4379 |
|
4380 void CVeiEditVideoView::NotifyVideoClipTimingsChanged( CVedMovie& /*aMovie*/, TInt /*aIndex*/ ) |
|
4381 { |
|
4382 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipTimingsChanged: in" ); |
|
4383 SetNewTempFileNeeded( ETrue ); |
|
4384 iMovieSavedFlag = EFalse; |
|
4385 UpdateEditNaviLabel(); |
|
4386 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipTimingsChanged: out" ); |
|
4387 } |
|
4388 |
|
4389 void CVeiEditVideoView::NotifyVideoClipColorEffectChanged( CVedMovie& /*aMovie*/, TInt /*aIndex*/ ) |
|
4390 { |
|
4391 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipColorEffectChanged: in" ); |
|
4392 SetNewTempFileNeeded( ETrue ); |
|
4393 iMovieSavedFlag = EFalse; |
|
4394 UpdateEditNaviLabel(); |
|
4395 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipColorEffectChanged: out" ); |
|
4396 } |
|
4397 |
|
4398 void CVeiEditVideoView::NotifyVideoClipAudioSettingsChanged( CVedMovie& /*aMovie*/, TInt /*aIndex*/ ) |
|
4399 { |
|
4400 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipAudioSettingsChanged: in" ); |
|
4401 SetNewTempFileNeeded( ETrue ); |
|
4402 iMovieSavedFlag = EFalse; |
|
4403 UpdateEditNaviLabel(); |
|
4404 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipAudioSettingsChanged: out" ); |
|
4405 } |
|
4406 |
|
4407 void CVeiEditVideoView::NotifyStartTransitionEffectChanged( CVedMovie& /*aMovie*/ ) |
|
4408 { |
|
4409 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyStartTransitionEffectChanged: in" ); |
|
4410 iMovieSavedFlag = EFalse; |
|
4411 SetNewTempFileNeeded( ETrue ); |
|
4412 UpdateEditNaviLabel(); |
|
4413 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyStartTransitionEffectChanged: out" ); |
|
4414 } |
|
4415 |
|
4416 void CVeiEditVideoView::NotifyMiddleTransitionEffectChanged( CVedMovie& /*aMovie*/, TInt /*aIndex*/ ) |
|
4417 { |
|
4418 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMiddleTransitionEffectChanged: in" ); |
|
4419 iMovieSavedFlag = EFalse; |
|
4420 SetNewTempFileNeeded( ETrue ); |
|
4421 UpdateEditNaviLabel(); |
|
4422 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMiddleTransitionEffectChanged: out" ); |
|
4423 } |
|
4424 |
|
4425 void CVeiEditVideoView::NotifyEndTransitionEffectChanged( CVedMovie& /*aMovie*/ ) |
|
4426 { |
|
4427 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyEndTransitionEffectChanged: in" ); |
|
4428 iMovieSavedFlag = EFalse; |
|
4429 SetNewTempFileNeeded( ETrue ); |
|
4430 UpdateEditNaviLabel(); |
|
4431 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyEndTransitionEffectChanged: out" ); |
|
4432 } |
|
4433 |
|
4434 void CVeiEditVideoView::NotifyAudioClipAdded( CVedMovie& aMovie, TInt aIndex ) |
|
4435 { |
|
4436 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipAdded: in" ); |
|
4437 iMovieSavedFlag = EFalse; |
|
4438 SetNewTempFileNeeded( ETrue ); |
|
4439 |
|
4440 if ( iProgressNote ) |
|
4441 { |
|
4442 iProgressNote->GetProgressInfoL()->SetAndDraw( 100 ); |
|
4443 TRAP_IGNORE( iProgressNote->ProcessFinishedL()); |
|
4444 } |
|
4445 |
|
4446 iOriginalAudioClipIndex = iContainer->CurrentIndex(); |
|
4447 |
|
4448 if ( iOriginalAudioClipIndex > aIndex ) |
|
4449 { |
|
4450 iOriginalAudioClipIndex--; |
|
4451 } |
|
4452 iContainer->SetCurrentIndex( aIndex ); |
|
4453 |
|
4454 iOriginalAudioStartPoint = TTimeIntervalMicroSeconds( - 1 ); |
|
4455 CVedAudioClipInfo* audioclipinfo = aMovie.AudioClipInfo( aIndex ); |
|
4456 iOriginalAudioDuration = audioclipinfo->Duration(); |
|
4457 |
|
4458 UpdateEditNaviLabel(); |
|
4459 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipAdded: out" ); |
|
4460 } |
|
4461 |
|
4462 void CVeiEditVideoView::NotifyAudioClipAddingFailed( CVedMovie& /*aMovie*/, TInt DEBUGLOG_ARG( aError )) |
|
4463 { |
|
4464 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipAddingFailed: in, aError:%d", aError ); |
|
4465 if ( iProgressNote ) |
|
4466 { |
|
4467 iProgressNote->GetProgressInfoL()->SetAndDraw( 100 ); |
|
4468 TRAP_IGNORE( iProgressNote->ProcessFinishedL()); |
|
4469 } |
|
4470 |
|
4471 if ( iWaitDialog ) |
|
4472 { |
|
4473 CancelWaitDialog(); |
|
4474 } |
|
4475 ShowErrorNote( R_VEI_ERRORNOTE_AUDIO_INSERTING_FAILED ); |
|
4476 |
|
4477 UpdateEditNaviLabel(); |
|
4478 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipAddingFailed: out" ); |
|
4479 } |
|
4480 |
|
4481 void CVeiEditVideoView::NotifyAudioClipRemoved( CVedMovie& /*aMovie*/, TInt /*aIndex*/ ) |
|
4482 { |
|
4483 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipRemoved: in" ); |
|
4484 if ( iTempRecordedAudio ) |
|
4485 { |
|
4486 delete iTempRecordedAudio; |
|
4487 iTempRecordedAudio = NULL; |
|
4488 } |
|
4489 iMovieSavedFlag = EFalse; |
|
4490 SetNewTempFileNeeded( ETrue ); |
|
4491 UpdateEditNaviLabel(); |
|
4492 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipRemoved: out" ); |
|
4493 } |
|
4494 |
|
4495 void CVeiEditVideoView::NotifyAudioClipIndicesChanged( CVedMovie& /*aMovie*/, TInt /*aOldIndex*/, TInt /*aNewIndex*/ ) |
|
4496 { |
|
4497 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipIndicesChanged: in" ); |
|
4498 iMovieSavedFlag = EFalse; |
|
4499 SetNewTempFileNeeded( ETrue ); |
|
4500 UpdateEditNaviLabel(); |
|
4501 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipIndicesChanged: out" ); |
|
4502 } |
|
4503 |
|
4504 void CVeiEditVideoView::NotifyAudioClipTimingsChanged( CVedMovie& /*aMovie*/, TInt /*aIndex*/ ) |
|
4505 { |
|
4506 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipTimingsChanged: in" ); |
|
4507 iMovieSavedFlag = EFalse; |
|
4508 SetNewTempFileNeeded( ETrue ); |
|
4509 UpdateEditNaviLabel(); |
|
4510 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipTimingsChanged: out" ); |
|
4511 } |
|
4512 |
|
4513 void CVeiEditVideoView::NotifyMovieReseted( CVedMovie& /*aMovie*/ ) |
|
4514 { |
|
4515 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieReseted: in" ); |
|
4516 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieReseted: out" ); |
|
4517 } |
|
4518 |
|
4519 void CVeiEditVideoView::NotifyAudioClipInfoReady( CVedAudioClipInfo& aInfo, TInt aError ) |
|
4520 { |
|
4521 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipInfoReady: in, aError:%d", aError ); |
|
4522 TInt err( KErrNone ); |
|
4523 |
|
4524 if ( aError == KErrNone ) |
|
4525 { |
|
4526 if ( aInfo.Type() == EVedAudioTypeUnrecognized ) |
|
4527 { |
|
4528 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipInfoReady: 2: EVedAudioTypeUnrecognized" ); |
|
4529 |
|
4530 aError = KErrNotSupported; |
|
4531 |
|
4532 /*TPtrC filename = aInfo.FileName(); |
|
4533 |
|
4534 iTempRecordedAudio = HBufC::NewL(KMaxFileName); |
|
4535 iTempMaker->GenerateTempFileName( *iTempRecordedAudio, iMovie ); |
|
4536 |
|
4537 TRAP_IGNORE( iConverter->StartConversionL( filename, *iTempRecordedAudio) ); |
|
4538 |
|
4539 delete iTempRecordedAudio; |
|
4540 iTempRecordedAudio = NULL; |
|
4541 */ |
|
4542 } |
|
4543 else if (( aInfo.Type() == EVedAudioTypeAMR ) || |
|
4544 ( aInfo.Type() == EVedAudioTypeAMRWB ) || |
|
4545 ( aInfo.Type() == EVedAudioTypeMP3 ) || |
|
4546 ( aInfo.Type() == EVedAudioTypeAAC_LC ) || |
|
4547 ( aInfo.Type() == EVedAudioTypeAAC_LTP ) || |
|
4548 ( aInfo.Type() == EVedAudioTypeWAV )) |
|
4549 { |
|
4550 |
|
4551 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipInfoReady: 3" ); |
|
4552 TInt index = 0; |
|
4553 TInt64 startTimeInt = 0; |
|
4554 TInt64 durationInt = aInfo.Duration().Int64(); |
|
4555 |
|
4556 if ((( iContainer->CursorLocation() == VideoEditor::ECursorOnAudio ) || |
|
4557 ( iContainer->CursorLocation() == VideoEditor::ECursorOnEmptyAudioTrack )) && |
|
4558 ( iMovie->AudioClipCount() > 0 )) |
|
4559 { |
|
4560 index = iContainer->CurrentIndex() + 1; |
|
4561 startTimeInt = iMovie->AudioClipEndTime( iContainer->CurrentIndex()).Int64(); |
|
4562 } |
|
4563 |
|
4564 while ( index < iMovie->AudioClipCount()) |
|
4565 { |
|
4566 if ( TTimeIntervalMicroSeconds( startTimeInt ) == iMovie->AudioClipStartTime( index )) |
|
4567 { |
|
4568 startTimeInt = iMovie->AudioClipEndTime( index ).Int64(); |
|
4569 index++; |
|
4570 } |
|
4571 else |
|
4572 { |
|
4573 break; |
|
4574 } |
|
4575 } |
|
4576 |
|
4577 if ( index < iMovie->AudioClipCount()) |
|
4578 { |
|
4579 TInt64 endTimeInt = startTimeInt + durationInt; |
|
4580 TInt64 nextStartTimeInt = iMovie->AudioClipStartTime( index ).Int64(); |
|
4581 if ( endTimeInt > nextStartTimeInt ) |
|
4582 { |
|
4583 durationInt = nextStartTimeInt - startTimeInt; |
|
4584 } |
|
4585 } |
|
4586 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipInfoReady: 4" ); |
|
4587 TRAP( err, iMovie->AddAudioClipL( aInfo.FileName(), |
|
4588 TTimeIntervalMicroSeconds( startTimeInt ), |
|
4589 TTimeIntervalMicroSeconds( 0 ), |
|
4590 TTimeIntervalMicroSeconds( durationInt ))); |
|
4591 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipInfoReady: 5" ); |
|
4592 } |
|
4593 } |
|
4594 if (( aError != KErrNone ) || ( err != KErrNone )) |
|
4595 { |
|
4596 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipInfoReady: 6" ); |
|
4597 if ( aError != KErrCancel ) |
|
4598 { |
|
4599 if ( aError ) |
|
4600 { |
|
4601 iErrorNmb = aError; |
|
4602 } |
|
4603 else |
|
4604 { |
|
4605 iErrorNmb = err; |
|
4606 } |
|
4607 } |
|
4608 iWaitMode = EProcessingAudioError; |
|
4609 |
|
4610 iProgressNote->GetProgressInfoL()->SetAndDraw( 100 ); |
|
4611 TRAP_IGNORE( iProgressNote->ProcessFinishedL()); |
|
4612 } |
|
4613 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipInfoReady: out" ); |
|
4614 } |
|
4615 |
|
4616 |
|
4617 |
|
4618 void CVeiEditVideoView::NotifyVideoClipGeneratorSettingsChanged( CVedMovie& /*aMovie*/, TInt /*aIndex*/ ) |
|
4619 { |
|
4620 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipGeneratorSettingsChanged: in" ); |
|
4621 if ( iWaitDialog ) |
|
4622 { |
|
4623 iWaitDialog->ProcessFinishedL(); |
|
4624 } |
|
4625 |
|
4626 SetNewTempFileNeeded( ETrue ); |
|
4627 iMovieSavedFlag = EFalse; |
|
4628 UpdateEditNaviLabel(); |
|
4629 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipGeneratorSettingsChanged: out" ); |
|
4630 } |
|
4631 |
|
4632 void CVeiEditVideoView::NotifyVideoClipDescriptiveNameChanged( CVedMovie& /*aMovie*/, TInt /*aIndex*/ ) |
|
4633 { |
|
4634 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipDescriptiveNameChanged: in and out" ); |
|
4635 } |
|
4636 |
|
4637 void CVeiEditVideoView::NotifyMovieQualityChanged( CVedMovie& /*aMovie*/ ) |
|
4638 { |
|
4639 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieQualityChanged: in" ); |
|
4640 |
|
4641 // If there are text generator inserted into the movie, they need |
|
4642 // to be notified that the movie resolution has changed so that |
|
4643 // they can re-calculate the the wrapping etc. parameters. |
|
4644 /* TInt clipCount = iMovie->VideoClipCount(); |
|
4645 for (TInt i = 0; i < clipCount; i++) |
|
4646 { |
|
4647 CVedVideoClipInfo* clipInfo = iMovie->VideoClipInfo(i); |
|
4648 if (clipInfo->Class() == EVedVideoClipClassGenerated) |
|
4649 { |
|
4650 TUid generatorUid = clipInfo->Generator()->Uid(); |
|
4651 if (generatorUid == KUidTitleClipGenerator) |
|
4652 { |
|
4653 CVeiTitleClipGenerator* generator = static_cast<CVeiTitleClipGenerator*>(clipInfo->Generator()); |
|
4654 generator->RefreshTextFrameParametersL(); |
|
4655 } |
|
4656 } |
|
4657 }*/ |
|
4658 |
|
4659 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieQualityChanged: out" ); |
|
4660 } |
|
4661 |
|
4662 void CVeiEditVideoView::NotifyMovieOutputParametersChanged( CVedMovie& /*aMovie*/ ) |
|
4663 { |
|
4664 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyMovieOutputParametersChanged: in and out" ); |
|
4665 SetNewTempFileNeeded( ETrue ); |
|
4666 iMovieSavedFlag = EFalse; |
|
4667 } |
|
4668 |
|
4669 void CVeiEditVideoView::NotifyAudioClipDynamicLevelMarkInserted( CVedMovie& /*aMovie*/, |
|
4670 TInt /*aClipIndex*/, |
|
4671 TInt /*aMarkIndex*/ ) |
|
4672 { |
|
4673 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipDynamicLevelMarkInserted: in and out" ); |
|
4674 SetNewTempFileNeeded( ETrue ); |
|
4675 iMovieSavedFlag = EFalse; |
|
4676 } |
|
4677 |
|
4678 void CVeiEditVideoView::NotifyAudioClipDynamicLevelMarkRemoved( CVedMovie& /*aMovie*/, |
|
4679 TInt /*aClipIndex*/, |
|
4680 TInt /*aMarkIndex*/ ) |
|
4681 { |
|
4682 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyAudioClipDynamicLevelMarkRemoved: in and out" ); |
|
4683 SetNewTempFileNeeded( ETrue ); |
|
4684 iMovieSavedFlag = EFalse; |
|
4685 } |
|
4686 |
|
4687 void CVeiEditVideoView::NotifyVideoClipDynamicLevelMarkInserted( CVedMovie& /*aMovie*/, |
|
4688 TInt /*aClipIndex*/, |
|
4689 TInt /*aMarkIndex*/ ) |
|
4690 { |
|
4691 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipDynamicLevelMarkInserted: in and out" ); |
|
4692 SetNewTempFileNeeded( ETrue ); |
|
4693 iMovieSavedFlag = EFalse; |
|
4694 } |
|
4695 |
|
4696 void CVeiEditVideoView::NotifyVideoClipDynamicLevelMarkRemoved( CVedMovie& /*aMovie*/, |
|
4697 TInt /*aClipIndex*/, |
|
4698 TInt /*aMarkIndex*/ ) |
|
4699 { |
|
4700 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyVideoClipDynamicLevelMarkRemoved: in and out" ); |
|
4701 SetNewTempFileNeeded( ETrue ); |
|
4702 iMovieSavedFlag = EFalse; |
|
4703 } |
|
4704 |
|
4705 void CVeiEditVideoView::MoscoStateChangeEvent( CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode ) |
|
4706 { |
|
4707 LOGFMT3( KVideoEditorLogFile, "CVeiEditVideoView::MoscoStateChangeEvent: In: aPreviousState:%d, aCurrentState:%d, aErrorCode:%d", aPreviousState, aCurrentState, aErrorCode ); |
|
4708 |
|
4709 if ( aObject == iRecorder ) |
|
4710 { |
|
4711 if ( aErrorCode != KErrNone ) |
|
4712 { |
|
4713 ShowErrorNote( R_VEI_RECORDING_FAILED ); |
|
4714 |
|
4715 if ( iTempRecordedAudio ) |
|
4716 { |
|
4717 TInt err = iEikonEnv->FsSession().Delete( *iTempRecordedAudio ); |
|
4718 if ( err ){ |
|
4719 |
|
4720 } |
|
4721 delete iTempRecordedAudio; |
|
4722 iTempRecordedAudio = NULL; |
|
4723 } |
|
4724 |
|
4725 iContainer->SetSelectionMode( CVeiEditVideoContainer::EModeNavigation ); |
|
4726 TRAP_IGNORE( Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK )); |
|
4727 Cba()->DrawDeferred(); |
|
4728 UpdateEditNaviLabel(); |
|
4729 |
|
4730 iRecorder->Close(); |
|
4731 } |
|
4732 else if ( aCurrentState == CMdaAudioClipUtility::ERecording ) |
|
4733 { |
|
4734 const TUint delay = 1000 * 1000 / 10; |
|
4735 |
|
4736 if ( !iAudioRecordPeriodic->IsActive()) |
|
4737 { |
|
4738 iAudioRecordPeriodic->Start( delay, delay, TCallBack( CVeiEditVideoView::UpdateAudioRecording, this )); |
|
4739 } |
|
4740 |
|
4741 Cba()->SetCommandSetL( R_VEI_SOFTKEYS_PAUSE_STOP ); |
|
4742 Cba()->DrawDeferred(); |
|
4743 } |
|
4744 else if ( aPreviousState == CMdaAudioClipUtility::ENotReady ) |
|
4745 { |
|
4746 TRAP_IGNORE( Cba()->SetCommandSetL( R_VEI_SOFTKEYS_RECORD_CANCEL )); |
|
4747 Cba()->DrawDeferred(); |
|
4748 } |
|
4749 } |
|
4750 |
|
4751 LOG( KVideoEditorLogFile, "CVeiEditVideoView::MoscoStateChangeEvent: Out" ); |
|
4752 } |
|
4753 |
|
4754 |
|
4755 void CVeiEditVideoView::DoActivateL( const TVwsViewId& /*aPrevViewId*/, |
|
4756 TUid /*aCustomMessageId*/, |
|
4757 const TDesC8& /*aCustomMessage*/ ) |
|
4758 { |
|
4759 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DoActivateL: In" ); |
|
4760 if ( !iMemoryCardChecked ) |
|
4761 { |
|
4762 CheckMemoryCardAvailabilityL(); |
|
4763 iMemoryCardChecked = ETrue; |
|
4764 } |
|
4765 |
|
4766 if ( !iContainer ) |
|
4767 { |
|
4768 iContainer = new( ELeave )CVeiEditVideoContainer( *iMovie, * this ); |
|
4769 iContainer->SetMopParent( this ); |
|
4770 iContainer->ConstructL( AppUi()->ClientRect()); |
|
4771 AppUi()->AddToStackL( *this, iContainer ); |
|
4772 } |
|
4773 |
|
4774 SetEditorState( EEdit ); |
|
4775 |
|
4776 // Add Context Pane icon |
|
4777 |
|
4778 /* TUid contextPaneUid; |
|
4779 contextPaneUid.iUid = EEikStatusPaneUidContext; |
|
4780 |
|
4781 CEikStatusPane* sp = StatusPane(); |
|
4782 CEikStatusPaneBase::TPaneCapabilities subPane = sp->PaneCapabilities( contextPaneUid ); |
|
4783 |
|
4784 if ( subPane.IsPresent() && subPane.IsAppOwned() ) |
|
4785 { |
|
4786 CAknContextPane* contextPane = (CAknContextPane*)sp->ControlL( contextPaneUid); |
|
4787 |
|
4788 TFileName mbmPath( VideoEditorUtils::IconFileNameAndPath(KManualVideoEditorIconFileId) ); |
|
4789 }*/ |
|
4790 |
|
4791 // Quality is taken from settings and set to engine. |
|
4792 STATIC_CAST( CVeiAppUi* , AppUi())->ReadSettingsL( iMovieSaveSettings ); |
|
4793 |
|
4794 TInt settingsSaveQuality = iMovieSaveSettings.SaveQuality(); |
|
4795 CVedMovie::TVedMovieQuality saveQuality; |
|
4796 |
|
4797 switch ( settingsSaveQuality ) |
|
4798 { |
|
4799 case TVeiSettings::EMmsCompatible: saveQuality = CVedMovie::EQualityMMSInteroperability; |
|
4800 break; |
|
4801 case TVeiSettings::EMedium: saveQuality = CVedMovie::EQualityResolutionMedium; |
|
4802 break; |
|
4803 case TVeiSettings::EBest: saveQuality = CVedMovie::EQualityResolutionHigh; |
|
4804 break; |
|
4805 case TVeiSettings::EAuto: default: |
|
4806 saveQuality = CVedMovie::EQualityAutomatic; |
|
4807 break; |
|
4808 } |
|
4809 |
|
4810 iMovie->SetQuality( saveQuality ); |
|
4811 iMemoryInUse = iMovieSaveSettings.MemoryInUse(); |
|
4812 |
|
4813 if (( EProcessingMovieForCutting == iWaitMode ) || |
|
4814 ( EProcessingMovieTrimMms == iWaitMode ) || |
|
4815 ( ECuttingAudio == iWaitMode )) |
|
4816 { |
|
4817 iMovie->RegisterMovieObserverL( this ); |
|
4818 iMovie->RegisterMovieObserverL( iContainer ); |
|
4819 } |
|
4820 |
|
4821 if ( EProcessingMovieForCutting == iWaitMode ) |
|
4822 { |
|
4823 // miksi laitetaan jos ollaan oltu rimmaamassa? |
|
4824 //SetNewTempFileNeeded(ETrue); |
|
4825 |
|
4826 TTimeIntervalMicroSeconds cutin; |
|
4827 TTimeIntervalMicroSeconds cutout; |
|
4828 cutin = iMovie->VideoClipCutInTime( iCutVideoIndex ); |
|
4829 cutout = iMovie->VideoClipCutOutTime( iCutVideoIndex ); |
|
4830 |
|
4831 if (( cutin != TTimeIntervalMicroSeconds( 0 )) || |
|
4832 ( cutout != iMovie->VideoClipInfo( iCutVideoIndex )->Duration())) |
|
4833 { |
|
4834 iMovieSavedFlag = EFalse; |
|
4835 } |
|
4836 |
|
4837 if (( cutin != iOriginalCutInTime ) || ( cutout != iOriginalCutOutTime ) ) |
|
4838 { |
|
4839 SetNewTempFileNeeded( ETrue ); |
|
4840 iContainer->DrawNow(); |
|
4841 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_EMPTY ); |
|
4842 iContainer->UpdateThumbnailL( iCutVideoIndex ); |
|
4843 } |
|
4844 iContainer->SetCursorLocation( VideoEditor::ECursorOnClip ); |
|
4845 } |
|
4846 else if ( ECuttingAudio == iWaitMode ) |
|
4847 { |
|
4848 |
|
4849 //SetNewTempFileNeeded(ETrue); |
|
4850 |
|
4851 TTimeIntervalMicroSeconds cutin; |
|
4852 TTimeIntervalMicroSeconds cutout; |
|
4853 cutin = iMovie->AudioClipCutInTime( iCutAudioIndex ); |
|
4854 cutout = iMovie->AudioClipCutOutTime( iCutAudioIndex ); |
|
4855 |
|
4856 if (( cutin != TTimeIntervalMicroSeconds( 0 )) || |
|
4857 ( cutout != iMovie->AudioClipInfo( iCutAudioIndex )->Duration())) |
|
4858 { |
|
4859 iMovieSavedFlag = EFalse; |
|
4860 } |
|
4861 |
|
4862 TTimeIntervalMicroSeconds currentEndTime; |
|
4863 TTimeIntervalMicroSeconds nextStartTime; |
|
4864 |
|
4865 for ( TInt i = iContainer->CurrentIndex(); i < ( iMovie->AudioClipCount() - 1 ); i++ ) |
|
4866 { |
|
4867 currentEndTime = iMovie->AudioClipEndTime( i ); |
|
4868 nextStartTime = iMovie->AudioClipStartTime( i + 1 ); |
|
4869 |
|
4870 if ( nextStartTime < currentEndTime ) |
|
4871 // what is the reason behind? |
|
4872 // is this a typo, should it be like this?: |
|
4873 //if ( nextStartTime != currentEndTime ) |
|
4874 { |
|
4875 nextStartTime = currentEndTime; |
|
4876 iMovie->AudioClipSetStartTime( i + 1, nextStartTime ); |
|
4877 } |
|
4878 } |
|
4879 if (( cutin != iOriginalAudioCutInTime ) || ( cutout != iOriginalAudioCutOutTime )) |
|
4880 { |
|
4881 SetNewTempFileNeeded( ETrue ); |
|
4882 iContainer->DrawNow(); |
|
4883 } |
|
4884 |
|
4885 iContainer->SetCursorLocation( VideoEditor::ECursorOnAudio ); |
|
4886 } |
|
4887 |
|
4888 iNaviPane->PushL( *iEditLabel ); |
|
4889 |
|
4890 iSendKey = EFalse; |
|
4891 iWaitMode = ENotWaiting; |
|
4892 |
|
4893 LOG( KVideoEditorLogFile, "CVeiEditVideoView::DoActivateL: out" ); |
|
4894 } |
|
4895 |
|
4896 void CVeiEditVideoView::HandleForegroundEventL( TBool aForeground ) |
|
4897 { |
|
4898 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::HandleForegroundEventL: in: %d", aForeground ); |
|
4899 |
|
4900 if ( !aForeground ) |
|
4901 { |
|
4902 // If the application is closing down, calling PauseVideoL could result in |
|
4903 // a callback from the MMF player after the container is already deleted, |
|
4904 // causing KERN-EXEC 3 |
|
4905 if ( static_cast < CVeiAppUi* > ( AppUi())->AppIsOnTheWayToDestruction()) |
|
4906 { |
|
4907 iContainer->PrepareForTerminationL(); |
|
4908 return ; |
|
4909 } |
|
4910 |
|
4911 LOG( KVideoEditorLogFile, "CVeiEditVideoView::HandleForegroundEventL 1" ); |
|
4912 //if ( (EditorState() != EEdit ) && iContainer) |
|
4913 if ( EPreview == EditorState() || EQuickPreview == EditorState()) |
|
4914 { |
|
4915 iContainer->PauseVideoL(); |
|
4916 } |
|
4917 // In phones with clamshell (läppäpuhelin) background can be activated with closing the shell |
|
4918 // iContainer's OfferKeyEvent do not get this kind of shell events |
|
4919 if ( EPreview == EditorState()) |
|
4920 // large preview |
|
4921 { |
|
4922 LOG( KVideoEditorLogFile, "CVeiEditVideoView::HandleForegroundEventL 2" ); |
|
4923 SetEditorState( CVeiEditVideoView::EEdit ); |
|
4924 iContainer->SetBlackScreen( EFalse ); |
|
4925 SetFullScreenSelected( EFalse ); |
|
4926 iContainer->StopVideo( ETrue ); |
|
4927 } |
|
4928 |
|
4929 if (( iContainer->SelectionMode() == CVeiEditVideoContainer::EModeRecordingPaused ) || ( iContainer->SelectionMode() == CVeiEditVideoContainer::EModeRecording )) |
|
4930 { |
|
4931 HandleCommandL( EVeiCmdEditVideoViewRecordStop ); |
|
4932 } |
|
4933 DoDeactivate(); |
|
4934 } |
|
4935 else |
|
4936 { |
|
4937 if ( EditorState() != EEdit ) |
|
4938 { |
|
4939 if ( EMixAudio != EditorState() && EAdjustVolume != EditorState()) |
|
4940 { |
|
4941 LOG( KVideoEditorLogFile, "CVeiEditVideoView::HandleForegroundEventL: 3, setting R_VEI_SOFTKEYS_PREVIEW_PLAY_BACK" ); |
|
4942 Cba()->SetCommandSetL( R_VEI_SOFTKEYS_PREVIEW_PLAY_BACK ); |
|
4943 } |
|
4944 Cba()->DrawDeferred(); |
|
4945 } |
|
4946 |
|
4947 /* When view is activated some clips can be deleted or |
|
4948 names can be changed.. So check that all video and audio clips are still available.*/ |
|
4949 if ( iMovie ) |
|
4950 { |
|
4951 TInt i; |
|
4952 TFileName clipName; |
|
4953 RFs& fs = iEikonEnv->FsSession(); |
|
4954 |
|
4955 for ( i = 0; i < iMovie->VideoClipCount(); i++ ) |
|
4956 { |
|
4957 if ( iMovie->VideoClipInfo( i )->Class() == EVedVideoClipClassFile ) |
|
4958 { |
|
4959 clipName = iMovie->VideoClipInfo( i )->FileName(); |
|
4960 |
|
4961 if ( !BaflUtils::FileExists( fs, clipName )) |
|
4962 { |
|
4963 iContainer->GetAndDecrementCurrentIndex(); |
|
4964 |
|
4965 iMovie->RemoveVideoClip( i ); |
|
4966 i--; |
|
4967 UpdateMediaGalleryL(); |
|
4968 } |
|
4969 clipName.Zero(); |
|
4970 } |
|
4971 } |
|
4972 |
|
4973 for ( i = 0; i < iMovie->AudioClipCount(); i++ ) |
|
4974 { |
|
4975 clipName = iMovie->AudioClipInfo( i )->FileName(); |
|
4976 |
|
4977 if ( !BaflUtils::FileExists( fs, clipName )) |
|
4978 { |
|
4979 iContainer->GetAndDecrementCurrentIndex(); |
|
4980 |
|
4981 iMovie->RemoveAudioClip( i ); |
|
4982 i--; |
|
4983 UpdateMediaGalleryL(); |
|
4984 } |
|
4985 clipName.Zero(); |
|
4986 } |
|
4987 |
|
4988 } |
|
4989 |
|
4990 UpdateEditNaviLabel(); |
|
4991 HandleScreenDeviceChangedL(); |
|
4992 } |
|
4993 |
|
4994 LOG( KVideoEditorLogFile, "CVeiEditVideoView::HandleForegroundEventL: out" ); |
|
4995 } |
|
4996 |
|
4997 void CVeiEditVideoView::DoDeactivate() |
|
4998 { |
|
4999 LOG( KVideoEditorLogFile, "CVeiEditVideoView:DoDeactivate: In" ); |
|
5000 |
|
5001 iNaviPane->Pop( iEditLabel ); |
|
5002 |
|
5003 if ( iVolumeHider ) |
|
5004 { |
|
5005 iVolumeHider->Cancel(); |
|
5006 delete iVolumeHider; |
|
5007 iVolumeHider = NULL; |
|
5008 } |
|
5009 |
|
5010 LOG( KVideoEditorLogFile, "CVeiEditVideoView:DoDeactivate: Out" ); |
|
5011 } |
|
5012 |
|
5013 |
|
5014 TTimeIntervalMicroSeconds CVeiEditVideoView::OriginalAudioDuration()const |
|
5015 { |
|
5016 return iOriginalAudioDuration; |
|
5017 } |
|
5018 |
|
5019 TInt CVeiEditVideoView::UpdateNaviPreviewing( TAny* aThis ) |
|
5020 { |
|
5021 STATIC_CAST( CVeiEditVideoView* , aThis )->DoUpdateEditNaviLabelL(); |
|
5022 return 1; |
|
5023 } |
|
5024 |
|
5025 |
|
5026 TInt CVeiEditVideoView::UpdateAudioRecording( TAny* aThis ) |
|
5027 { |
|
5028 STATIC_CAST( CVeiEditVideoView* , aThis )->DoUpdateAudioRecording(); |
|
5029 return 1; |
|
5030 } |
|
5031 |
|
5032 void CVeiEditVideoView::DoUpdateAudioRecording() |
|
5033 { |
|
5034 if ( iRecorder->State() != CMdaAudioClipUtility::ERecording ) |
|
5035 { |
|
5036 iAudioRecordPeriodic->Cancel(); |
|
5037 Cba()->SetCommandSetL( R_VEI_SOFTKEYS_CONTINUE_STOP ); |
|
5038 Cba()->DrawDeferred(); |
|
5039 } |
|
5040 else |
|
5041 { |
|
5042 TTimeIntervalMicroSeconds duration = iRecorder->Duration(); |
|
5043 |
|
5044 iContainer->SetRecordedAudioDuration( duration ); |
|
5045 iContainer->DrawTrackBoxes(); |
|
5046 |
|
5047 UpdateEditNaviLabel(); |
|
5048 |
|
5049 // !!!*** Safety margin of 0.5s because cropping does not work, remove when cropping fixed. ***!!! |
|
5050 duration = TTimeIntervalMicroSeconds( duration.Int64()); |
|
5051 |
|
5052 if (( iRecordedAudioMaxDuration >= TTimeIntervalMicroSeconds( 0 )) && ( duration > iRecordedAudioMaxDuration )) |
|
5053 { |
|
5054 TRAP_IGNORE( HandleCommandL( EVeiCmdEditVideoViewRecordStop )); |
|
5055 } |
|
5056 } |
|
5057 } |
|
5058 |
|
5059 void CVeiEditVideoView::CancelWaitDialog( TInt aError ) |
|
5060 { |
|
5061 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::CancelWaitDialog: In, aError:%d", aError ); |
|
5062 if ( iWaitDialog ) |
|
5063 { |
|
5064 LOG( KVideoEditorLogFile, "CVeiEditVideoView::CancelWaitDialog: 2" ); |
|
5065 iWaitDialog->ProcessFinishedL(); |
|
5066 } |
|
5067 |
|
5068 if ( aError ) |
|
5069 { |
|
5070 LOG( KVideoEditorLogFile, "CVeiEditVideoView::CancelWaitDialog: 3" ); |
|
5071 ShowGlobalErrorNote( aError ); |
|
5072 LOG( KVideoEditorLogFile, "CVeiEditVideoView::CancelWaitDialog: 4" ); |
|
5073 } |
|
5074 Cba()->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK ); |
|
5075 LOG( KVideoEditorLogFile, "CVeiEditVideoView::CancelWaitDialog: 5" ); |
|
5076 Cba()->DrawDeferred(); |
|
5077 LOG( KVideoEditorLogFile, "CVeiEditVideoView::CancelWaitDialog: Out" ); |
|
5078 } |
|
5079 |
|
5080 void CVeiEditVideoView::NotifyImageClipGeneratorInitializationComplete( CVeiImageClipGenerator& /*aGenerator*/, TInt aError ) |
|
5081 { |
|
5082 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::NotifyImageClipGeneratorInitializationComplete: in, aError:%d", aError ); |
|
5083 if ( aError != KErrNone ) |
|
5084 { |
|
5085 ShowGlobalErrorNote( aError ); |
|
5086 delete iGenerator; |
|
5087 iGenerator = 0; |
|
5088 return ; |
|
5089 } |
|
5090 |
|
5091 // insert the generator into movie |
|
5092 TInt index = ( iContainer->CurrentIndex() == iMovie->VideoClipCount()) ? iMovie->VideoClipCount(): iContainer->CurrentIndex() + 1; |
|
5093 iMovie->InsertVideoClipL( *iGenerator, ETrue, index ); |
|
5094 |
|
5095 // Generator is no longer our concern |
|
5096 iGenerator = 0; |
|
5097 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyImageClipGeneratorInitializationComplete: out" ); |
|
5098 } |
|
5099 |
|
5100 |
|
5101 void CVeiEditVideoView::NotifyTitleClipBackgroundImageLoadComplete( CVeiTitleClipGenerator& /*aGenerator*/, TInt aError ) |
|
5102 { |
|
5103 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::NotifyTitleClipBackgroundImageLoadComplete: in, aError:%d", aError ); |
|
5104 if ( aError != KErrNone ) |
|
5105 { |
|
5106 ShowGlobalErrorNote( aError ); |
|
5107 delete iGenerator; |
|
5108 iGenerator = 0; |
|
5109 return ; |
|
5110 } |
|
5111 LOG( KVideoEditorLogFile, "CVeiEditVideoView::NotifyTitleClipBackgroundImageLoadComplete: out" ); |
|
5112 } |
|
5113 |
|
5114 void CVeiEditVideoView::UpdateInsertingProgressNoteL( TInt aProcessed ) |
|
5115 { |
|
5116 TInt queueCount = iMediaQueue->Count(); |
|
5117 |
|
5118 CArrayFix < TInt > * numbers = new CArrayFixFlat < TInt > ( 2 ); |
|
5119 CleanupStack::PushL( numbers ); |
|
5120 numbers->AppendL( aProcessed ); |
|
5121 numbers->AppendL( queueCount ); |
|
5122 |
|
5123 HBufC* stringholder = StringLoader::LoadL( R_VEI_PROGRESS_NOTE_INSERTING_MEDIA, * numbers, iEikonEnv ); |
|
5124 |
|
5125 CleanupStack::PushL( stringholder ); |
|
5126 |
|
5127 iProgressNote->SetTextL( *stringholder ); |
|
5128 iProgressNote->DrawNow(); // otherwise text is not drawn at all |
|
5129 CleanupStack::PopAndDestroy( stringholder ); |
|
5130 CleanupStack::PopAndDestroy( numbers ); |
|
5131 } |
|
5132 |
|
5133 void CVeiEditVideoView::MmsSendCompatibleCheck() |
|
5134 { |
|
5135 LOG( KVideoEditorLogFile, "CVeiEditVideoView::MmsSendCompatibleCheck(): in" ); |
|
5136 |
|
5137 TInt maxMmsSize = STATIC_CAST( CVeiEditVideoLabelNavi* , iEditLabel->DecoratedControl())->GetMaxMmsSize()* 1024; |
|
5138 |
|
5139 CVedMovie::TVedMovieQuality origQuality = iMovie->Quality(); |
|
5140 iMovie->SetQuality( CVedMovie::EQualityMMSInteroperability ); |
|
5141 TInt sizeEstimate = 0; |
|
5142 TRAP_IGNORE( sizeEstimate = iMovie->GetSizeEstimateL()); |
|
5143 iMovie->SetQuality( origQuality ); |
|
5144 |
|
5145 LOGFMT2( KVideoEditorLogFile, "CVeiEditVideoView::MmsSendCompatibleCheck(): maxMmsSize: %d, sizeEstimate: %d", maxMmsSize, sizeEstimate ); |
|
5146 |
|
5147 TInt movieSizeLimit = ( TInt )( maxMmsSize* 0.9 ); |
|
5148 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::MmsSendCompatibleCheck(): testing, test:%d", movieSizeLimit ); |
|
5149 |
|
5150 if ( sizeEstimate < ( TInt )( maxMmsSize* 1.1 )) |
|
5151 { |
|
5152 LOG( KVideoEditorLogFile, "CVeiEditVideoView::MmsSendCompatibleCheck(): SetMovieSizeLimit..ok" ); |
|
5153 iMovie->SetMovieSizeLimit( movieSizeLimit ); |
|
5154 } |
|
5155 |
|
5156 TVeiSettings movieSaveSettings; |
|
5157 |
|
5158 if ( iMovie->IsMovieMMSCompatible()) |
|
5159 { |
|
5160 LOG( KVideoEditorLogFile, "CVeiEditVideoView::MmsSendCompatibleCheck: MMSCompatible YES" ); |
|
5161 iWaitMode = EProcessingMovieTrimMms; |
|
5162 StartTempFileProcessingL(); |
|
5163 } |
|
5164 else |
|
5165 { |
|
5166 LOG( KVideoEditorLogFile, "CVeiEditVideoView::MmsSendCompatibleCheck: MMSCompatible NO" ); |
|
5167 iWaitMode = EProcessingMovieTrimMms; |
|
5168 movieSaveSettings.SaveQuality() = TVeiSettings::EMmsCompatible; |
|
5169 StartTempFileProcessingL(); |
|
5170 } |
|
5171 LOG( KVideoEditorLogFile, "CVeiEditVideoView::MmsSendCompatibleCheck(): out" ); |
|
5172 } |
|
5173 |
|
5174 // Screen twisting |
|
5175 /* |
|
5176 /* experimental code trying to fix this: |
|
5177 EECO-6W39YS |
|
5178 Manual Video Editor: Wrong layout displays if switching phone mode during large preview playing |
|
5179 |
|
5180 void CVeiEditVideoView::HandleScreenDeviceChangedL() |
|
5181 { |
|
5182 LOG(KVideoEditorLogFile, "CVeiEditVideoView::HandleScreenDeviceChangedL() in"); |
|
5183 if ( iContainer ) |
|
5184 { |
|
5185 // Orientation changed. Resize container rect and update component |
|
5186 //positions. |
|
5187 |
|
5188 |
|
5189 // iContainer->SetRect( ClientOrApplicationRect( iFullScreenSelected ) ); |
|
5190 // |
|
5191 // iContainer->SetRect( AppUi()->ClientRect() ); |
|
5192 // |
|
5193 |
|
5194 if(CVeiEditVideoContainer::EModePreview == iContainer->SelectionMode() && iFullScreenSelected && |
|
5195 CVeiEditVideoContainer::EStatePlaying == iContainer->PreviewState()) |
|
5196 { |
|
5197 LOG(KVideoEditorLogFile, "CVeiEditVideoView::HandleScreenDeviceChangedL() 1"); |
|
5198 iContainer->SetBlackScreen( ETrue ); |
|
5199 iContainer->SetRect( ClientOrApplicationRect( iFullScreenSelected ) ); |
|
5200 return; |
|
5201 } |
|
5202 LOG(KVideoEditorLogFile, "CVeiEditVideoView::HandleScreenDeviceChangedL() 2"); |
|
5203 iContainer->SetCursorLocation( iContainer->CursorLocation() ); |
|
5204 iContainer->ArrowsControl(); |
|
5205 |
|
5206 iContainer->DrawDeferred(); |
|
5207 } |
|
5208 LOG(KVideoEditorLogFile, "CVeiEditVideoView::HandleScreenDeviceChangedL() out"); |
|
5209 } |
|
5210 */ |
|
5211 /* Screen twisting */ |
|
5212 void CVeiEditVideoView::HandleScreenDeviceChangedL() |
|
5213 { |
|
5214 if ( iContainer ) |
|
5215 { |
|
5216 // Orientation changed. Resize container rect and update component |
|
5217 //positions. |
|
5218 iContainer->SetRect( AppUi()->ClientRect()); |
|
5219 |
|
5220 iContainer->SetCursorLocation( iContainer->CursorLocation()); |
|
5221 iContainer->ArrowsControl(); |
|
5222 |
|
5223 iContainer->DrawDeferred(); |
|
5224 } |
|
5225 } |
|
5226 |
|
5227 void CVeiEditVideoView::HideVolume() |
|
5228 { |
|
5229 iNaviPane->Pop( iVolumeNavi ); |
|
5230 |
|
5231 delete iVolumeHider; |
|
5232 iVolumeHider = NULL; |
|
5233 } |
|
5234 |
|
5235 TInt CVeiEditVideoView::HideVolumeCallbackL( TAny* aPtr ) |
|
5236 { |
|
5237 CVeiEditVideoView* view = ( CVeiEditVideoView* )aPtr; |
|
5238 view->HideVolume(); |
|
5239 return 0; |
|
5240 } |
|
5241 |
|
5242 void CVeiEditVideoView::UpdateMediaGalleryL() |
|
5243 { |
|
5244 LOG( KVideoEditorLogFile, "CVeiEditVideoView::UpdateMediaGalleryL(): In" ); |
|
5245 |
|
5246 |
|
5247 // Publish & Subscribe API used to make the saved file name available to AIW provider |
|
5248 if ( iSaveToFileName ) |
|
5249 { |
|
5250 LOG( KVideoEditorLogFile, "CVeiEditVideoView::UpdateMediaGalleryL(): Calling RProperty::Define(KUidVideoEditorProperties, VideoEditor::EPropertyFilename, RProperty::EText); " ); |
|
5251 TInt err = RProperty::Define( KUidVideoEditorProperties, VideoEditor::EPropertyFilename, RProperty::EText ); |
|
5252 if ( err != KErrAlreadyExists ) |
|
5253 { |
|
5254 User::LeaveIfError( err ); |
|
5255 } |
|
5256 User::LeaveIfError( RProperty::Set( KUidVideoEditorProperties, VideoEditor::EPropertyFilename, iSaveToFileName->Des())); |
|
5257 } |
|
5258 LOG( KVideoEditorLogFile, "CVeiEditVideoView::UpdateMediaGalleryL(): Out" ); |
|
5259 } |
|
5260 |
|
5261 void CVeiEditVideoView::SetFullScreenSelected( TBool aFullScreenSelected ) |
|
5262 { |
|
5263 iFullScreenSelected = aFullScreenSelected; |
|
5264 } |
|
5265 |
|
5266 void CVeiEditVideoView::StartNaviPaneUpdateL() |
|
5267 { |
|
5268 if ( iPreviewUpdatePeriodic ) |
|
5269 { |
|
5270 if ( iPreviewUpdatePeriodic->IsActive()) |
|
5271 { |
|
5272 iPreviewUpdatePeriodic->Cancel(); |
|
5273 } |
|
5274 |
|
5275 iPreviewUpdatePeriodic->Start( 100000, 100000, TCallBack( CVeiEditVideoView::UpdateNaviPreviewing, this )); |
|
5276 } |
|
5277 } |
|
5278 |
|
5279 void CVeiEditVideoView::ShowAndHandleSendMenuCommandsL() |
|
5280 { |
|
5281 /* Show send menu, postcard dimmed */ |
|
5282 CArrayFix < TUid > * mtmToDim = new( ELeave )CArrayFixFlat < TUid > ( 3 ); |
|
5283 TUid userSelection; |
|
5284 CleanupStack::PushL( mtmToDim ); |
|
5285 /* |
|
5286 this uid is empirically got with one device 19.10.2006 |
|
5287 there is currently (19.10.2006) no constans found in headers for Web Upload |
|
5288 */ |
|
5289 |
|
5290 const TInt KSenduiMtmOwnWebUploadIntValue = 536873429; |
|
5291 const TUid KSenduiMtmOwnWebUpload = |
|
5292 { |
|
5293 KSenduiMtmOwnWebUploadIntValue |
|
5294 }; |
|
5295 |
|
5296 mtmToDim->AppendL( KSenduiMtmPostcardUid ); |
|
5297 mtmToDim->AppendL( KSenduiMtmAudioMessageUid ); |
|
5298 mtmToDim->AppendL( KSenduiMtmOwnWebUpload ); |
|
5299 |
|
5300 |
|
5301 userSelection = iSendAppUi.ShowSendQueryL( NULL, TSendingCapabilities( 0, 0, TSendingCapabilities::ESupportsAttachments ), mtmToDim ); |
|
5302 CleanupStack::PopAndDestroy( mtmToDim ); |
|
5303 |
|
5304 iGivenSendCommand = userSelection; |
|
5305 |
|
5306 if ( IsEnoughFreeSpaceToSaveL()) |
|
5307 { |
|
5308 switch ( userSelection.iUid ) |
|
5309 { |
|
5310 case KSenduiMtmSmtpUidValue: |
|
5311 case KSenduiMtmImap4UidValue: |
|
5312 case KSenduiMtmPop3UidValue: |
|
5313 { |
|
5314 LOGFMT( KVideoEditorLogFile, "CVeiEditVideoView::ShowAndHandleSendMenuCommandsL: MTM UID: %d", userSelection.iUid ); |
|
5315 iWaitMode = EProcessingMovieSend; |
|
5316 StartTempFileProcessingL(); |
|
5317 break; |
|
5318 } |
|
5319 case KSenduiMtmIrUidValue: |
|
5320 { |
|
5321 LOG( KVideoEditorLogFile, "CVeiEditVideoView::ShowAndHandleSendMenuCommandsL: MTM UID: KSenduiMtmIrUidValue" ); |
|
5322 iWaitMode = EProcessingMovieSend; |
|
5323 StartTempFileProcessingL(); |
|
5324 break; |
|
5325 } |
|
5326 case KSenduiMtmMmsUidValue: |
|
5327 { |
|
5328 LOG( KVideoEditorLogFile, "CVeiEditVideoView::ShowAndHandleSendMenuCommandsL: MTM UID: KSenduiMtmMmsUidValue" ); |
|
5329 iWaitMode = EProcessingMovieTrimMms; |
|
5330 MmsSendCompatibleCheck(); |
|
5331 break; |
|
5332 } |
|
5333 case KSenduiMtmBtUidValue: |
|
5334 { |
|
5335 LOG( KVideoEditorLogFile, "CVeiEditVideoView::ShowAndHandleSendMenuCommandsL: MTM UID: KSenduiMtmBtUidValue" ); |
|
5336 iWaitMode = EProcessingMovieSend; |
|
5337 StartTempFileProcessingL(); |
|
5338 break; |
|
5339 } |
|
5340 /*case KSenduiMtmOwnWebUploadIntValue: // 0x200009D5 |
|
5341 { |
|
5342 LOG(KVideoEditorLogFile, "CVeiEditVideoView::ShowAndHandleSendMenuCommandsL 6: MTM UID: 536873429"); |
|
5343 iWaitMode = EProcessingMovieSend; |
|
5344 StartTempFileProcessingL(); |
|
5345 break; |
|
5346 } |
|
5347 */ |
|
5348 default: |
|
5349 break; |
|
5350 |
|
5351 } |
|
5352 } |
|
5353 } |
|
5354 |
|
5355 void CVeiEditVideoView::StopNaviPaneUpdateL() |
|
5356 { |
|
5357 DoUpdateEditNaviLabelL(); |
|
5358 |
|
5359 if ( iPreviewUpdatePeriodic && iPreviewUpdatePeriodic->IsActive()) |
|
5360 { |
|
5361 iPreviewUpdatePeriodic->Cancel(); |
|
5362 } |
|
5363 } |
|
5364 |
|
5365 TRect CVeiEditVideoView::ClientOrApplicationRect( TBool aFullScreenSelected )const |
|
5366 { |
|
5367 if ( aFullScreenSelected ) |
|
5368 { |
|
5369 return AppUi()->ApplicationRect(); |
|
5370 } |
|
5371 else |
|
5372 { |
|
5373 return AppUi()->ClientRect(); |
|
5374 } |
|
5375 |
|
5376 } |
|
5377 |
|
5378 TBool CVeiEditVideoView::MixingConditionsOk()const |
|
5379 { |
|
5380 // prerequisites for sound mixing: at least one video with audio and one imported audio exist |
|
5381 if ( iMovie->VideoClipCount() > 0 && iMovie->AudioClipCount() > 0 ) |
|
5382 { |
|
5383 for ( TInt i = 0; i < iMovie->VideoClipCount(); i++ ) |
|
5384 { |
|
5385 //if (iMovie->VideoClipEditedHasAudio(i)) |
|
5386 if ( iMovie->VideoClipInfo( i )->HasAudio()) |
|
5387 { |
|
5388 return ETrue; |
|
5389 } |
|
5390 } |
|
5391 } |
|
5392 return EFalse; |
|
5393 } |
|
5394 |
|
5395 /*void CVeiEditVideoView::MixAudio() |
|
5396 { |
|
5397 |
|
5398 //TReal gainVideoNew(0); |
|
5399 //TReal gainAudioNew(0); |
|
5400 |
|
5401 TInt gainVideoNew(0); |
|
5402 TInt gainAudioNew(0); |
|
5403 |
|
5404 TInt gainVideoCurrent = iMovie->GetVideoClipVolumeGainL(KVedClipIndexAll); |
|
5405 TInt gainAudioCurrent = iMovie->GetAudioClipVolumeGainL(KVedClipIndexAll); |
|
5406 |
|
5407 // video clips are faded |
|
5408 if (iContainer->AudioMixingRatio() > 0) |
|
5409 { |
|
5410 //@ : think how to tackle situations where value is form x.0, adding 0.5 gets wrong int |
|
5411 //Math::Round(fadevideo, iContainer->AudioMixingRatio()*(KVolumeMaxGain/10), 2); |
|
5412 |
|
5413 gainVideoNew = iContainer->AudioMixingRatio()*(KVolumeMaxGain/10); |
|
5414 gainVideoNew += 0.5; // for making real to int rounding work in constructor of TVedDynamicLevelMark |
|
5415 gainVideoNew = 0 - gainVideoNew; |
|
5416 } |
|
5417 // audio clips are faded |
|
5418 else if (iContainer->AudioMixingRatio() < 0) |
|
5419 { |
|
5420 //@ : think how to tackle situations where value is form x.0, adding 0.5 gets wrong int |
|
5421 //Math::Round(fadeaudio, iContainer->AudioMixingRatio()*(KVolumeMaxGain/10), 2); |
|
5422 gainAudioNew = iContainer->AudioMixingRatio()*(KVolumeMaxGain/10); |
|
5423 gainAudioNew -= 0.5; // for making real to int rounding work in constructor of TVedDynamicLevelMark |
|
5424 } |
|
5425 |
|
5426 if (gainVideoNew != gainVideoCurrent) |
|
5427 { |
|
5428 iMovie->SetVideoClipVolumeGainL(KVedClipIndexAll, gainVideoNew); |
|
5429 } |
|
5430 if (gainAudioNew != gainAudioCurrent) |
|
5431 { |
|
5432 iMovie->SetAudioClipVolumeGainL(KVedClipIndexAll, gainAudioNew); |
|
5433 } |
|
5434 } |
|
5435 */ |
|
5436 |
|
5437 void CVeiEditVideoView::MixAudio() |
|
5438 { |
|
5439 TReal fadevideo( 0 ); |
|
5440 TReal fadeaudio( 0 ); |
|
5441 |
|
5442 // video clips are faded |
|
5443 if ( iContainer->AudioMixingRatio() > 0 ) |
|
5444 { |
|
5445 //@ : think how to tackle situations where value is form x.0, adding 0.5 gets wrong int |
|
5446 //Math::Round(fadevideo, iContainer->AudioMixingRatio()*(KVolumeMaxGain/10), 2); |
|
5447 |
|
5448 fadevideo = iContainer->AudioMixingRatio()*( KVolumeMaxGain / 10 ); |
|
5449 fadevideo += 0.5; // for making real to int rounding work in constructor of TVedDynamicLevelMark |
|
5450 fadevideo = 0-fadevideo; |
|
5451 fadeaudio = 0; |
|
5452 } |
|
5453 // audio clips are faded |
|
5454 else if ( iContainer->AudioMixingRatio() < 0 ) |
|
5455 { |
|
5456 //@ : think how to tackle situations where value is form x.0, adding 0.5 gets wrong int |
|
5457 //Math::Round(fadeaudio, iContainer->AudioMixingRatio()*(KVolumeMaxGain/10), 2); |
|
5458 |
|
5459 fadeaudio = iContainer->AudioMixingRatio()*( KVolumeMaxGain / 10 ); |
|
5460 fadeaudio -= 0.5; // for making real to int rounding work in constructor of TVedDynamicLevelMark |
|
5461 fadevideo = 0; |
|
5462 } |
|
5463 |
|
5464 // video clips are faded |
|
5465 if ( iContainer->AudioMixingRatio() > 0 && iMovie->VideoClipCount() > 0 ) |
|
5466 { |
|
5467 TInt gain = iMovie->GetVideoClipVolumeGainL( KVedClipIndexAll ); ///(KVolumeMaxGain/10); |
|
5468 TInt gainNew = ( TInt )fadevideo; |
|
5469 if ( gainNew != gain ) |
|
5470 { |
|
5471 iMovie->SetAudioClipVolumeGainL( KVedClipIndexAll, 0 ); |
|
5472 iMovie->SetVideoClipVolumeGainL( KVedClipIndexAll, gainNew ); |
|
5473 } |
|
5474 } |
|
5475 // audio clips are faded |
|
5476 else if ( iContainer->AudioMixingRatio() < 0 && iMovie->AudioClipCount() > 0 ) |
|
5477 { |
|
5478 TInt gain = iMovie->GetAudioClipVolumeGainL( KVedClipIndexAll ); ///(KVolumeMaxGain/10); |
|
5479 TInt gainNew = ( TInt )fadeaudio; |
|
5480 if ( gainNew != gain ) |
|
5481 { |
|
5482 iMovie->SetVideoClipVolumeGainL( KVedClipIndexAll, 0 ); |
|
5483 iMovie->SetAudioClipVolumeGainL( KVedClipIndexAll, gainNew ); |
|
5484 } |
|
5485 } |
|
5486 else |
|
5487 //if marks set back to position '0' |
|
5488 { |
|
5489 if ( 0 != iMovie->GetVideoClipVolumeGainL( KVedClipIndexAll )) |
|
5490 { |
|
5491 iMovie->SetVideoClipVolumeGainL( KVedClipIndexAll, 0 ); |
|
5492 } |
|
5493 if ( 0 != iMovie->GetAudioClipVolumeGainL( KVedClipIndexAll )) |
|
5494 { |
|
5495 iMovie->SetAudioClipVolumeGainL( KVedClipIndexAll, 0 ); |
|
5496 } |
|
5497 } |
|
5498 } |
|
5499 |
|
5500 void CVeiEditVideoView::AdjustVolumeL() |
|
5501 { |
|
5502 TReal adjustVolume = iContainer->Volume()*( KVolumeMaxGain / 10 ); |
|
5503 // to make rounding to int work correctly in constructor of TVedDynamicLevelMark |
|
5504 // @ : if adjustvolume is x.0, rounding does not work, think how to fix problem |
|
5505 if ( 0 < adjustVolume ) |
|
5506 { |
|
5507 adjustVolume += 0.5; |
|
5508 } |
|
5509 else |
|
5510 { |
|
5511 adjustVolume -= 0.5; |
|
5512 } |
|
5513 |
|
5514 if ( iContainer->CursorLocation() == VideoEditor::ECursorOnClip ) |
|
5515 { |
|
5516 TReal currentVolume = iMovie->GetVideoClipVolumeGainL( iContainer->CurrentIndex()); ///(KVolumeMaxGain/10); |
|
5517 if ( 0 == iContainer->Volume()) |
|
5518 { |
|
5519 if ( 0 != ( TInt )currentVolume ) |
|
5520 { |
|
5521 iMovie->SetVideoClipVolumeGainL( iContainer->CurrentIndex(), 0 ); |
|
5522 } |
|
5523 } |
|
5524 else if (( TInt )currentVolume != ( TInt )adjustVolume ) |
|
5525 { |
|
5526 iMovie->SetVideoClipVolumeGainL( iContainer->CurrentIndex(), ( TInt )adjustVolume ); |
|
5527 } |
|
5528 } |
|
5529 else if ( iContainer->CursorLocation() == VideoEditor::ECursorOnAudio ) |
|
5530 { |
|
5531 TReal currentVolume = iMovie->GetAudioClipVolumeGainL( iContainer->CurrentIndex()); ///(KVolumeMaxGain/10); |
|
5532 if ( 0 == iContainer->Volume()) |
|
5533 { |
|
5534 if ( 0 != ( TInt )currentVolume ) |
|
5535 { |
|
5536 iMovie->SetAudioClipVolumeGainL( iContainer->CurrentIndex(), 0 ); |
|
5537 } |
|
5538 } |
|
5539 else if (( TInt )currentVolume != ( TInt )adjustVolume ) |
|
5540 { |
|
5541 iMovie->SetAudioClipVolumeGainL( iContainer->CurrentIndex(), ( TInt )adjustVolume ); |
|
5542 } |
|
5543 } |
|
5544 } |
|
5545 |
|
5546 void CVeiEditVideoView::StoreOrientation() |
|
5547 { |
|
5548 LOG( KVideoEditorLogFile, "CVeiEditVideoView::StoreOrientation: in" ); |
|
5549 |
|
5550 iOriginalOrientation = AppUi()->Orientation(); |
|
5551 |
|
5552 LOG( KVideoEditorLogFile, "CVeiEditVideoView::StoreOrientation: out" ); |
|
5553 } |
|
5554 |
|
5555 void CVeiEditVideoView::RestoreOrientation() |
|
5556 { |
|
5557 LOG( KVideoEditorLogFile, "CVeiEditVideoView::RestoreOrientation: in" ); |
|
5558 |
|
5559 TRAP_IGNORE( AppUi()->SetOrientationL( iOriginalOrientation )); |
|
5560 |
|
5561 LOG( KVideoEditorLogFile, "CVeiEditVideoView::RestoreOrientation: out" ); |
|
5562 } |
|
5563 |
|
5564 void CVeiEditVideoView::SetNewTempFileNeeded( const TBool aUpdateNeeded ) |
|
5565 { |
|
5566 iUpdateTemp = aUpdateNeeded; |
|
5567 } |
|
5568 |
|
5569 // End of File |