1 /*

     2 * Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "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 *

    14 * Description:  

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include "CPbkObserverAdapter.h"

    22 #include <MPbkImageOperationObservers.h>

    23 

    24 // ============================= LOCAL FUNCTIONS ===============================

    25 

    26 /// Unnamed namespace for local definitions

    27 namespace {

    28 

    29 // LOCAL CONSTANTS AND MACROS

    30 /// Panic codes 

    31 enum TPanicCode

    32     {    

    33     EPanicPreCond_PbkThumbnailGetComplete=1,

    34     EPanicPreCond_PbkThumbnailGetFailed,

    35     EPanicPreCond_PbkThumbnailSetComplete,

    36     EPanicPreCond_PbkThumbnailSetFailed,

    37     EPanicPreCond_PbkThumbnailGetImageComplete,

    38     EPanicPreCond_PbkThumbnailGetImageFailed,

    39     EPanicPreCond_PbkThumbnailGetObserver,

    40     EPanicPreCond_PbkThumbnailSetObserver,

    41     EPanicPreCond_PbkThumbnailGetImageObserver 

    42 

    43     };

    44 

    45 void Panic(TPanicCode aReason)

    46     {

    47     _LIT(KPanicText, "CPbkObserverAdapter");

    48     User::Panic(KPanicText, aReason);

    49     }

    50 

    51 }  // namespace

    52 

    53 

    54 // ============================ MEMBER FUNCTIONS ===============================

    55 

    56 // -----------------------------------------------------------------------------

    57 // CPbkObserverAdapter::CPbkObserverAdapter

    58 // C++ default constructor can NOT contain any code, that

    59 // might leave.

    60 // -----------------------------------------------------------------------------

    61 //

    62 CPbkObserverAdapter::CPbkObserverAdapter()

    63     {

    64     }

    65 

    66 // -----------------------------------------------------------------------------

    67 // CPbkObserverAdapter::ConstructL

    68 // Symbian 2nd phase constructor can leave.

    69 // -----------------------------------------------------------------------------

    70 //

    71 void CPbkObserverAdapter::ConstructL()

    72     {

    73     }

    74 

    75 // -----------------------------------------------------------------------------

    76 // CPbkObserverAdapter::NewL

    77 // Two-phased constructor.

    78 // -----------------------------------------------------------------------------

    79 //

    80 CPbkObserverAdapter* CPbkObserverAdapter::NewL()

    81     {

    82     CPbkObserverAdapter* self = new( ELeave ) CPbkObserverAdapter;

    83     

    84     CleanupStack::PushL( self );

    85     self->ConstructL();

    86     CleanupStack::Pop();

    87 

    88     return self;

    89     }

    90 

    91     

    92 // Destructor

    93 CPbkObserverAdapter::~CPbkObserverAdapter()

    94     {    

    95     }

    96 

    97 void CPbkObserverAdapter::DoSetImageGetObserver(MPbkImageGetObserver& 

    98     aPbkImageGetObserver)

    99     {

   100     iPbkImageGetObserver = &aPbkImageGetObserver;

   101     }

   102 

   103 MPbkImageGetObserver* CPbkObserverAdapter::ImageGetObserver()

   104     {

   105     return iPbkImageGetObserver;

   106     }

   107 

   108 void CPbkObserverAdapter::PbkThumbnailGetComplete

   109     (MPbkThumbnailOperation& aOperation, CFbsBitmap* aBitmap)

   110     {

   111     __ASSERT_ALWAYS(iPbkImageGetObserver, Panic(

   112         EPanicPreCond_PbkThumbnailGetComplete));

   113 

   114     // MPbkImageOperation and MPbkThumbnailOperation are identical. 

   115     // Both contain only the destructor. More complex implementation avoided 

   116     // by using reinterpret cast. Otherwise there might be a need to generate 

   117     // a new thumbnail operation adapter instance when MPbkImageGetObserver's 

   118     // method is called once.

   119     

   120 // TODO reinterpret_cast causes a crash 

   121 // TO BE CONTINUED wrapper needed for MPbkImageOperation and MPbkThumbnailOperation conversion

   122     iPbkImageGetObserver->PbkImageGetComplete(

   123         reinterpret_cast<MPbkImageOperation&>(aOperation),aBitmap);

   124     }

   125 

   126 void CPbkObserverAdapter::PbkThumbnailGetFailed

   127     (MPbkThumbnailOperation& aOperation, TInt aError)

   128     {

   129     __ASSERT_ALWAYS(iPbkImageGetObserver, Panic(

   130         EPanicPreCond_PbkThumbnailGetFailed));

   131     // MPbkImageOperation and MPbkThumbnailOperation are identical. 

   132     iPbkImageGetObserver->PbkImageGetFailed(

   133         reinterpret_cast<MPbkImageOperation&>(aOperation), aError);

   134     }

   135 

   136 

   137 void CPbkObserverAdapter::DoSetImageSetObserver(MPbkImageSetObserver& 

   138     aPbkImageSetObserver)

   139     {

   140     iPbkImageSetObserver = &aPbkImageSetObserver;

   141     }

   142 

   143 MPbkImageSetObserver* CPbkObserverAdapter::ImageSetObserver()

   144     {

   145     return iPbkImageSetObserver;

   146     }

   147 

   148 void CPbkObserverAdapter::PbkThumbnailSetComplete(

   149     MPbkThumbnailOperation& aOperation)

   150     {

   151     __ASSERT_ALWAYS(iPbkImageSetObserver, Panic(

   152         EPanicPreCond_PbkThumbnailSetComplete));

   153     // MPbkImageOperation and MPbkThumbnailOperation are identical.

   154     iPbkImageSetObserver->PbkImageSetComplete(

   155         reinterpret_cast<MPbkImageOperation&>(aOperation));

   156     }

   157 void CPbkObserverAdapter::PbkThumbnailSetFailed(

   158     MPbkThumbnailOperation& aOperation, TInt aError)

   159     {

   160     __ASSERT_ALWAYS(iPbkImageGetObserver, Panic(

   161         EPanicPreCond_PbkThumbnailSetFailed));

   162     // MPbkImageOperation and MPbkThumbnailOperation are identical.

   163     iPbkImageSetObserver->PbkImageSetFailed(

   164         reinterpret_cast<MPbkImageOperation&>(aOperation), aError);

   165     }

   166 

   167 void CPbkObserverAdapter::DoSetImageGetImageObserver(MPbkImageGetImageObserver& 

   168             aPbkImageGetImageObserver)

   169     {

   170     iPbkImageGetImageObserver = &aPbkImageGetImageObserver;

   171     }

   172 

   173 MPbkImageGetImageObserver* CPbkObserverAdapter::ImageGetImageObserver()

   174     {

   175     return iPbkImageGetImageObserver;

   176     }

   177 

   178 void CPbkObserverAdapter::PbkThumbnailGetImageComplete

   179     (MPbkThumbnailOperation& aOperation, CPbkImageDataWithInfo* aImageData)

   180     {

   181     __ASSERT_ALWAYS(iPbkImageGetImageObserver, 

   182         Panic(EPanicPreCond_PbkThumbnailGetImageComplete));

   183     // MPbkImageOperation and MPbkThumbnailOperation are identical.

   184     iPbkImageGetImageObserver->PbkImageGetImageComplete(

   185         reinterpret_cast<MPbkImageOperation&>(aOperation), aImageData);

   186     }

   187 

   188 void CPbkObserverAdapter::PbkThumbnailGetImageFailed

   189     (MPbkThumbnailOperation& aOperation, TInt aError)

   190     {

   191     __ASSERT_ALWAYS(iPbkImageGetImageObserver, 

   192         Panic(EPanicPreCond_PbkThumbnailGetImageFailed));

   193     // MPbkImageOperation and MPbkThumbnailOperation are identical.

   194     iPbkImageGetImageObserver->PbkImageGetImageFailed(

   195         reinterpret_cast<MPbkImageOperation&>(aOperation), aError);        

   196     }

   197 

   198 void CPbkObserverAdapter::SetPbkImageGetObserver(MPbkImageGetObserver& aObserver)

   199     {

   200     // TODO: Multiple observer might need to be supported

   201     DoSetImageGetObserver(aObserver);

   202     }

   203 

   204 MPbkThumbnailGetObserver& CPbkObserverAdapter::PbkThumbnailGetObserver()

   205     {

   206     MPbkImageGetObserver* currentObserver = ImageGetObserver();

   207     if (!currentObserver)

   208         {

   209         // Observer must be set before use of this function

   210         Panic( EPanicPreCond_PbkThumbnailGetObserver );

   211         }

   212     return *this;

   213     }

   214 

   215 void CPbkObserverAdapter::SetPbkImageSetObserver(MPbkImageSetObserver& aObserver)

   216     {

   217     // TODO: Multiple observer might need to be supported

   218     DoSetImageSetObserver(aObserver);

   219     }

   220 

   221 MPbkThumbnailSetObserver& CPbkObserverAdapter::PbkThumbnailSetObserver()

   222     {

   223     MPbkImageSetObserver* currentObserver = ImageSetObserver();

   224     if (!currentObserver)

   225         {

   226         // Observer must be set before use of this function

   227         Panic( EPanicPreCond_PbkThumbnailSetObserver );

   228         }

   229     return *this;

   230     }

   231 

   232 void CPbkObserverAdapter::SetPbkImageGetImageObserver(

   233         MPbkImageGetImageObserver& aObserver)

   234     {

   235     // TODO: Multiple observer might need to be supported

   236     DoSetImageGetImageObserver(aObserver);

   237     }

   238 

   239 MPbkThumbnailGetImageObserver& CPbkObserverAdapter::PbkThumbnailGetImageObserver()

   240     {

   241     MPbkImageGetImageObserver* currentObserver = ImageGetImageObserver();

   242 

   243     if (!currentObserver)

   244         {

   245         // Observer must be set before use of this function

   246         Panic( EPanicPreCond_PbkThumbnailGetImageObserver );

   247         }

   248     return *this;

   249     }

   250 

   251 //  End of File