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 

    21 #include <fbs.h>

    22 #include <utf.h>

    23 #include <eikenv.h>

    24 

    25 #include "ImageEditorPluginManager.h"

    26 #include "ImageEditorManagerDef.h"

    27 

    28 #include "PluginBaseDefs.h"

    29 #include "ImageEditorPluginBaseDefs.h"

    30 #include "ImageEditorPluginBase.hrh"

    31 #include "iepb.h"

    32 #include "ImageEditorError.h"

    33 

    34 #include "ImageEditorEngineWrapper.h"

    35 #include "PluginLoader.h"

    36 #include "EditorImage.h"

    37 #include "SystemParameters.h"

    38 #include "ResolutionUtil.h"

    39 

    40 #ifdef RD_CONTENTNOTIFICATION

    41 

    42 // For notifying Media Gallery of new files

    43 //#include <contentnotification.hrh> // notification event type definitions

    44 #include <contentnotification.h>

    45 #include <contentcreatedevent.h>

    46 

    47 #endif //RD_CONTENTNOTIFICATION

    48 // LOCAL CONSTANTS

    49 

    50 _LIT( KComponentName, "ImageEditorPluginManager"); // Panic category

    51 const TInt KImageEditorPluginManagerPanicNoPluginLoaded = 0; 

    52 

    53 

    54 //=============================================================================

    55 EXPORT_C CImageEditorPluginManager * CImageEditorPluginManager::NewL ()

    56 {

    57 	CImageEditorPluginManager * self = new (ELeave) CImageEditorPluginManager;

    58 	CleanupStack::PushL (self);

    59 	self->ConstructL();

    60 	CleanupStack::Pop(); // self

    61 	return self;

    62 }

    63 

    64 //=============================================================================

    65 EXPORT_C CImageEditorPluginManager::~CImageEditorPluginManager ()

    66 {

    67 	Cleanup();

    68     delete iPluginLoader;

    69  #ifdef RD_CONTENTNOTIFICATION

    70     delete iEventNotifier;

    71  #endif

    72 }

    73 

    74 //=============================================================================

    75 EXPORT_C void CImageEditorPluginManager::OpenPluginL (const TDesC &	aFileName)

    76 {

    77     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Opening plugin");

    78 

    79 	//	Load plug-in

    80     iPluginLoader = CPluginLoader::NewL (aFileName, &TUid2, NULL);

    81 

    82 	// Get the plug-in filter type

    83 	TBuf<256>	iobuf;  

    84 	iPluginLoader->GetPlugin()->GetProperty (KCapPluginFilterType, iobuf);

    85 	TLex lex (iobuf);

    86 	iFilterType = 0;

    87 	lex.Val (iFilterType);

    88 

    89     // Get the plug-in ui type

    90 	iobuf.Zero();

    91 	iPluginLoader->GetPlugin()->GetProperty (KCapPluginUiType, iobuf);

    92 	lex.Assign (iobuf);

    93 	iUiType = 0;

    94 	lex.Val (iUiType);

    95 

    96     // Disable global zoom / pan if plug-in does not support it 

    97     iobuf.Zero();

    98     TInt temp = 0;

    99     iGlobalZoomDisabled = EFalse;

   100     iPluginLoader->GetPlugin()->GetProperty (KCapGlobalZoomDisabled, iobuf);

   101 	lex.Assign (iobuf);

   102 	lex.Val (temp);

   103     iGlobalZoomDisabled = (TBool)temp;

   104     if (iGlobalZoomDisabled)

   105     {

   106         // Store old zoom value for restore

   107         iEngineWrapper->StoreZoomL();

   108         RenderL();

   109     }

   110 

   111 	//	Add filter to the engine.

   112 	AddFilterToEngineL();

   113 

   114     //  Add system parameters to plug-in

   115     CSystemParameters * syspars = iEngineWrapper->GetSystemPars();

   116     iobuf.Zero();

   117 	iobuf.AppendNum ((TInt)((TAny *)(syspars)));

   118     iPluginLoader->GetPlugin()->SetProperty (KCapSystemParameters, iobuf);

   119 

   120 

   121 }

   122 

   123 //=============================================================================

   124 EXPORT_C TInt CImageEditorPluginManager::CreatePluginControlL (

   125 	const TRect &	aRect,

   126 	CCoeControl *	aParent,

   127 	CCoeControl *&	aPluginControl

   128 	)

   129 {

   130     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Creating plugin control");

   131     

   132     //	Initialize plug-in control

   133     if (iPluginLoader)

   134     {

   135         TInt ret = KErrGeneral;

   136         CPluginType* plugin = iPluginLoader->GetPlugin();

   137         if ( plugin )

   138         {

   139             ret = plugin->InitPluginL (aRect, aParent, aPluginControl);

   140         }

   141         return ret;

   142     }

   143     else

   144     {

   145         aPluginControl = 0;

   146         return KErrGeneral;

   147     }

   148 }

   149 

   150 //=============================================================================

   151 EXPORT_C void CImageEditorPluginManager::ClosePlugin()

   152 {

   153     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Closing plugin");

   154 

   155     if (iPluginLoader && !iOnTheWayToDestruction)

   156     {

   157         //  Enable zoom if disabled

   158         if (iGlobalZoomDisabled)

   159         {   

   160             TRAP_IGNORE(iEngineWrapper->RestoreZoomL());

   161         }

   162 		TRAP_IGNORE(ProcessImageL());

   163     }

   164 

   165     //  Delete and unload current plug-in

   166     delete iPluginLoader;

   167     iPluginLoader = NULL;

   168     iFilterType = NULL;

   169     iUiType = NULL;

   170     iGlobalZoomDisabled = EFalse;

   171 }

   172 

   173 //=============================================================================

   174 EXPORT_C void CImageEditorPluginManager::ShowPluginPopup()

   175 {

   176     if (iPluginLoader)

   177     {

   178         CPluginType* plugin = iPluginLoader->GetPlugin();

   179         if ( plugin )

   180         {

   181             plugin->ShowPopupNote ();

   182         }

   183     }

   184 }

   185 

   186 //=============================================================================

   187 EXPORT_C void CImageEditorPluginManager::UndoL()

   188 {

   189     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Undoing");

   190     

   191     //	Undo step

   192 	iEngineWrapper->UndoL();

   193 

   194 	//	Render

   195 	RenderL();

   196 

   197 }

   198 

   199 //=============================================================================

   200 EXPORT_C void CImageEditorPluginManager::RedoL()

   201 {

   202     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Redoing");

   203 }

   204 

   205 //=============================================================================

   206 EXPORT_C void CImageEditorPluginManager::LoadImageL(const TBool aUseIPECodec)

   207 {

   208 

   209     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Loading image");

   210 

   211 	if ( aUseIPECodec )

   212 	{

   213 	    //	Create new jpeg source

   214 		iEngineWrapper->CreateJpegSourceL ( iImage->GetImageName() );

   215 	}

   216 	else

   217 	{

   218 	    //	Create new icl source

   219 		iEngineWrapper->CreateIclSourceL ( iImage->GetImageName() );

   220 	}

   221 

   222 	//	Render

   223 	RenderL();

   224 }

   225 

   226 //=============================================================================

   227 EXPORT_C void CImageEditorPluginManager::SaveImageL (

   228     const TInt      aQuality,

   229     const TSize *   aSize

   230     )

   231 {

   232     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Saving image");

   233 

   234     //	Create RAJPEG sink

   235 	iEngineWrapper->CreateJpegTargetL (iImage->GetImageName(), aQuality, aSize);

   236 

   237 	//	Render

   238 	iEngineWrapper->RenderL ();

   239 }

   240 

   241 //=============================================================================

   242 EXPORT_C void CImageEditorPluginManager::PrepareAsyncSaveL (

   243     const TInt      aQuality,

   244     const TSize *   aSize

   245     )

   246     {

   247     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Preparing for async save");

   248 

   249 	//  Disable and store zoom

   250 	iEngineWrapper->StoreZoomL();

   251 

   252     //	Create new EXIF thumbnail

   253 	iEngineWrapper->CreateExifThumbNailL ();

   254 

   255     //	Create RAJPEG sink

   256 	iEngineWrapper->CreateJpegTargetL  (iImage->GetImageName(), aQuality, aSize);

   257 

   258     //  Start rendering

   259     iEngineWrapper->RenderL ();

   260     }

   261 

   262 //=============================================================================

   263 EXPORT_C TInt CImageEditorPluginManager::SaveBlockL ()

   264     {

   265    	//	Render

   266     return iEngineWrapper->RenderBlockL();

   267     }

   268 

   269 //=============================================================================

   270 EXPORT_C void CImageEditorPluginManager::SaveAbortL ()

   271     {

   272     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Saving aborted");

   273 

   274     iEngineWrapper->RenderAbortL();

   275 

   276 	iEngineWrapper->RestoreZoomL();

   277 

   278     RenderL();

   279     }

   280 

   281 //=============================================================================

   282 EXPORT_C void CImageEditorPluginManager::FinishAsyncSaveL ()

   283     {

   284     LOG(KImageEditorLogFile, "CImageEditorPluginManager::FinishAsyncSaveL");

   285 

   286 #ifdef RD_CONTENTNOTIFICATION    

   287     TArray<CContentNotificationEvent*> eventArray;

   288     

   289     // Nofication about new content

   290 	CContentNotificationEvent* event = CContentCreatedEvent::NewLC( iImage->GetImageName() );

   291 	eventArray->AppendL( event );

   292 	CleanupStack::Pop( event );

   293 

   294     User::LeaveIfError(iEventNotifier->SendNotification( eventArray ));

   295     delete event;

   296     delete eventArray;

   297 #endif

   298     

   299     iEngineWrapper->RestoreZoomL();

   300      

   301     RenderL();

   302     }

   303 

   304 

   305 //=============================================================================

   306 EXPORT_C void CImageEditorPluginManager::ProcessImageL()

   307 {

   308     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Rendering image");

   309 

   310 	//	Set filter parameters

   311 	SetParametersL();

   312 

   313     //	Render

   314  	RenderL ();

   315 }

   316 

   317 //=============================================================================

   318 EXPORT_C void CImageEditorPluginManager::PrepareAsyncProcessL (TInt& aBlockCount)

   319 {

   320 	//	Set filter parameters

   321 	SetParametersL();

   322 

   323     // Start rendering

   324     RenderL (&aBlockCount);

   325 }

   326 

   327 //=============================================================================

   328 EXPORT_C TInt CImageEditorPluginManager::ProcessBlockL()

   329 {

   330     //	Render

   331  	return iEngineWrapper->RenderBlockL ();

   332 }

   333 

   334 //=============================================================================

   335 EXPORT_C void CImageEditorPluginManager::FinishAsyncProcess()

   336 {

   337 

   338 }

   339 

   340 //=============================================================================

   341 EXPORT_C CFbsBitmap * CImageEditorPluginManager::GetPreviewImage()

   342 {

   343 	return iImage->GetPreviewData();

   344 }

   345 

   346 //=============================================================================

   347 EXPORT_C CFbsBitmap * CImageEditorPluginManager::GetFullImage()

   348 {

   349 	return iImage->GetFullData();

   350 }

   351 

   352 //=============================================================================

   353 EXPORT_C const TDesC & CImageEditorPluginManager::GetImageName()

   354 {

   355 	return iImage->GetImageName();

   356 }

   357 

   358 //=============================================================================

   359 EXPORT_C void CImageEditorPluginManager::SetPreviewImage (CFbsBitmap * aBitmap)

   360 {

   361 	iImage->GetPreviewData() = aBitmap;

   362 }

   363 

   364 //=============================================================================

   365 EXPORT_C void CImageEditorPluginManager::SetFullImage (CFbsBitmap * aBitmap)

   366 {

   367 	iImage->GetFullData() = aBitmap;

   368 }

   369 

   370 //=============================================================================

   371 EXPORT_C void CImageEditorPluginManager::SetImageName (const TDesC & aFileName)

   372 {

   373 	iImage->GetImageName().Copy ( aFileName );

   374 }

   375 

   376 //=============================================================================

   377 EXPORT_C void CImageEditorPluginManager::ResetEngineL()

   378 {

   379 	//	Clean up

   380 	Cleanup();

   381     

   382     //  Create a new MIA engine

   383     iEngineWrapper = CEngineWrapper::NewL();

   384 }

   385 

   386 //=============================================================================

   387 EXPORT_C void CImageEditorPluginManager::PurgeUndoRedoHistory()

   388 {

   389     iEngineWrapper->InitUndoRedo();

   390 }

   391 

   392 //=============================================================================

   393 EXPORT_C TBool CImageEditorPluginManager::CanUndo()

   394 {

   395     return iEngineWrapper->CanUndo();

   396 }

   397 

   398 //=============================================================================

   399 EXPORT_C TBool CImageEditorPluginManager::IsImageChanged()

   400 {

   401     return iEngineWrapper->IsImageChanged();

   402 }

   403 

   404 //=============================================================================

   405 EXPORT_C TBool CImageEditorPluginManager::IsLandscapeEnabledL() const

   406 {

   407     TBool ret = ETrue;

   408     

   409     if (iPluginLoader)

   410         {

   411         TBuf<256>	iobuf; 

   412         TInt err = iPluginLoader->GetPlugin()->GetProperty(KCapIsLandscapeEnabled, iobuf);

   413         if (err != KErrNone)

   414             {

   415             User::Leave(KSIEEInternal);

   416             }

   417         else

   418             {

   419             TLex parser(iobuf);

   420             User::LeaveIfError(parser.Val(ret));

   421             }

   422         }

   423 

   424     return ret;

   425 }

   426 

   427 //=============================================================================

   428 CImageEditorPluginManager::CImageEditorPluginManager () 

   429 : iGlobalZoomDisabled(EFalse), iOnTheWayToDestruction (EFalse)

   430 {

   431 

   432 }

   433 

   434 //=============================================================================

   435 void CImageEditorPluginManager::ConstructL ()

   436 {

   437     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Creating manager");

   438     //  Create new image

   439 	iImage = CEditorImage::NewL ();

   440 

   441     //  Create a new MIA engine

   442     iEngineWrapper = CEngineWrapper::NewL();

   443 

   444 #ifdef RD_CONTENTNOTIFICATION

   445     iEventNotifier = CContentNotification::NewL ();

   446 #endif 

   447 

   448 	//  Get the screen size from the Resolution Util

   449     TRect rect;

   450     CResolutionUtil::Self()->GetClientRect(rect);

   451     TSize size = rect.Size();

   452 

   453     //  Set screen size to the engine

   454    iEngineWrapper->SetScreenSizeL (size);

   455 }

   456 

   457 //=============================================================================

   458 EXPORT_C void CImageEditorPluginManager::SetScreenSizeL () 

   459 {

   460     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Setting new screen size");

   461 

   462 	iEngineWrapper->CreateRGB888TargetL ();

   463 	

   464     //  Get the screen size from the Resolution Util

   465     TRect rect;

   466     CResolutionUtil::Self()->GetClientRect(rect);

   467     TSize size = rect.Size();

   468 

   469     //  Set screen size to the engine

   470     iEngineWrapper->SetScreenSizeL (size);

   471 

   472     //  Render to new screen size

   473     RenderL();

   474 

   475 	//	Compute system parameters

   476 	iEngineWrapper->GetSystemPars();

   477 }

   478 

   479 

   480 //=============================================================================

   481 void CImageEditorPluginManager::SetParametersL()

   482 {

   483     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Setting parameters");

   484 

   485 	if (EPluginFilterTypeABITO == iFilterType)

   486 	{

   487 		//	used as a buffer

   488 		TBuf<256> param; 

   489 			

   490 		TInt err = iPluginLoader->GetPlugin()->GetProperty(KCapParamStruct, param);

   491 

   492 		//	If cancelling, there might not be a control, KErrNotReady returned

   493 		//	Ignore KErrNotReady

   494         if ( (err != KErrNone) && (err != KErrNotReady) )

   495 		{

   496             User::Leave(KSIEEInternal);

   497         }

   498 

   499 		iEngineWrapper->SetParamsL (param);

   500 	}

   501 }

   502 

   503 //=============================================================================

   504 void CImageEditorPluginManager::RenderL (TInt * aMultiSessionBlockCount)

   505 {

   506     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Rendering");

   507 

   508 	TBuf<256>	iobuf;  

   509 	TBool readyToRender = ETrue;

   510 

   511     // Check that filter can be rendered

   512     if ( iPluginLoader && iFilterType == EPluginFilterTypeABITO )

   513 	    {

   514         TInt err = iPluginLoader->GetPlugin()->GetProperty(KCapReadyToRender, iobuf);

   515         if (err != KErrNone)

   516             {

   517             User::Leave(KSIEEInternal);

   518             }

   519         else

   520             {

   521             TLex parser(iobuf);

   522             User::LeaveIfError(parser.Val(readyToRender));

   523             }

   524         }

   525 

   526 	if (readyToRender)

   527 		{

   528 		iEngineWrapper->SetBitmap ( iImage->GetPreviewData() );

   529 		iEngineWrapper->CreateRGB888TargetL ();

   530 	    iEngineWrapper->RenderL (aMultiSessionBlockCount);

   531 		}    

   532 

   533         

   534 }

   535 

   536 //=============================================================================

   537 EXPORT_C void CImageEditorPluginManager::AddFilterToEngineL()

   538 {

   539     LOG(KImageEditorLogFile, "CImageEditorPluginManager: Adding filter to engine");

   540 

   541 	//	Add undo-redo step

   542     iEngineWrapper->AddUndoRedoStepL();

   543 

   544     if (EPluginFilterTypeABITO == iFilterType)

   545     {

   546 

   547 		TBuf<256>	iobuf;  

   548 		TLex 		parser;

   549 

   550         //	Add filter to the engine

   551 	    TFileName	filterFile;

   552         CPluginType* plugin = iPluginLoader->GetPlugin(); // must not return null

   553         __ASSERT_ALWAYS( plugin, User::Panic(KComponentName, KImageEditorPluginManagerPanicNoPluginLoaded) );

   554 

   555         User::LeaveIfError( plugin->GetProperty (KCapFilterName, iobuf) );

   556         filterFile.Copy ( iobuf );

   557 

   558         // Construct full dll path

   559         TFileName filterNameAndPath( KPluginDriveAndPath );

   560         filterNameAndPath.Append( filterFile );

   561 

   562         LOGFMT( KImageEditorLogFile,"\tPlug-in file: %S", &filterNameAndPath );

   563 

   564         iobuf.Zero();

   565         User::LeaveIfError( iPluginLoader->GetPlugin()->GetProperty (KCapPluginScope, iobuf) );

   566         parser = iobuf;

   567         parser.Val (iPluginScope);

   568     

   569         iEngineWrapper->AddFilterL ( filterNameAndPath );

   570     }

   571 }

   572 

   573 //=============================================================================

   574 void CImageEditorPluginManager::Cleanup()

   575 {

   576     iOnTheWayToDestruction = ETrue;

   577 

   578 	//	Close plug-in

   579 	ClosePlugin();

   580 

   581 	//	Delete engine

   582     delete iEngineWrapper;

   583 	iEngineWrapper = NULL;

   584 

   585 	//	Delete editor image

   586     delete iImage;

   587 	iImage = NULL;

   588 }

   589 

   590 

   591 //=============================================================================

   592 EXPORT_C void CImageEditorPluginManager::ZoomL (const TZoom aZoom)

   593     {

   594     if( !iGlobalZoomDisabled )

   595     	{

   596     	iEngineWrapper->ZoomL (aZoom);

   597     	}

   598     }

   599     

   600 //=============================================================================

   601 EXPORT_C TZoomMode CImageEditorPluginManager::GetZoomMode()

   602     {

   603     return iEngineWrapper->GetZoomMode();

   604     }

   605     

   606 //=============================================================================

   607 EXPORT_C void CImageEditorPluginManager::PanL (const TDirection aDir)

   608     {

   609     iEngineWrapper->PanL (aDir);

   610     }

   611 

   612 //=============================================================================    

   613 EXPORT_C void CImageEditorPluginManager::PanL( TInt aXChange, TInt aYChange )

   614     {

   615     iEngineWrapper->PanL( aXChange, aYChange );

   616     }

   617 

   618 //=============================================================================

   619 EXPORT_C void CImageEditorPluginManager::RotateL (const TRotation aRot)

   620     {

   621    	//	Rotate image

   622     iEngineWrapper->RotateL (aRot);

   623     }

   624 

   625 //=============================================================================

   626 EXPORT_C const CSystemParameters & CImageEditorPluginManager::GetSystemParameters() const

   627 {

   628     return *iEngineWrapper->GetSystemPars();

   629 }

   630 

   631 //=============================================================================

   632 EXPORT_C TBool CImageEditorPluginManager::IsPluginLoaded () const

   633 {

   634     if (iPluginLoader)

   635     {

   636         return ETrue;

   637     }

   638     else

   639     {

   640         return EFalse;

   641     }

   642 }

   643 

   644 

   645 //=============================================================================

   646 EXPORT_C void CImageEditorPluginManager::RestoreFilterL() const

   647 {

   648 

   649 }

   650 

   651 // End of file