1 /*

     2 * Copyright (c) 2006-2007 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:  Implementation class of Thumbnail Manager.

    15  *

    16 */

    17 // Created by TraceCompiler 2.3.0

    18 // DO NOT EDIT, CHANGES WILL BE LOST

    19 

    20 #ifndef __THUMBNAILMANAGERIMPLTRACES_H__

    21 #define __THUMBNAILMANAGERIMPLTRACES_H__

    22 

    23 #define KOstTraceComponentID 0x102830aa

    24 

    25 #define CTHUMBNAILMANAGERIMPL_CTHUMBNAILMANAGERIMPL 0x860007

    26 #define DUP1_CTHUMBNAILMANAGERIMPL_CTHUMBNAILMANAGERIMPL 0x860008

    27 #define DUP2_CTHUMBNAILMANAGERIMPL_CTHUMBNAILMANAGERIMPL 0x860009

    28 #define DUP3_CTHUMBNAILMANAGERIMPL_CTHUMBNAILMANAGERIMPL 0x86000a

    29 #define DUP4_CTHUMBNAILMANAGERIMPL_CTHUMBNAILMANAGERIMPL 0x86000b

    30 #define CTHUMBNAILMANAGERIMPL_CONSTRUCTL 0x86000c

    31 #define DUP1_CTHUMBNAILMANAGERIMPL_CONSTRUCTL 0x86000d

    32 #define DUP2_CTHUMBNAILMANAGERIMPL_CONSTRUCTL 0x86000e

    33 #define DUP3_CTHUMBNAILMANAGERIMPL_CONSTRUCTL 0x86000f

    34 #define DUP4_CTHUMBNAILMANAGERIMPL_CONSTRUCTL 0x860010

    35 #define CTHUMBNAILMANAGERIMPL_GETTHUMBNAILL 0x860011

    36 #define DUP1_CTHUMBNAILMANAGERIMPL_GETTHUMBNAILL 0x860012

    37 #define DUP2_CTHUMBNAILMANAGERIMPL_GETTHUMBNAILL 0x860013

    38 #define DUP3_CTHUMBNAILMANAGERIMPL_GETTHUMBNAILL 0x860014

    39 #define CTHUMBNAILMANAGERIMPL_IMPORTTHUMBNAILL 0x860015

    40 #define CTHUMBNAILMANAGERIMPL_SETTHUMBNAILL 0x860016

    41 #define CTHUMBNAILMANAGERIMPL_CREATETHUMBNAILS 0x860017

    42 #define DUP1_CTHUMBNAILMANAGERIMPL_CREATETHUMBNAILS 0x860018

    43 #define CTHUMBNAILMANAGERIMPL_DELETETHUMBNAILS 0x860019

    44 #define DUP1_CTHUMBNAILMANAGERIMPL_DELETETHUMBNAILS 0x86001a

    45 #define CTHUMBNAILMANAGERIMPL_CANCELREQUEST 0x86001b

    46 #define CTHUMBNAILMANAGERIMPL_CHANGEPRIORITY 0x86001c

    47 #define CTHUMBNAILMANAGERIMPL_UPDATETHUMBNAILSL 0x86001d

    48 #define CTHUMBNAILMANAGERIMPL_RENAMETHUMBNAILSL 0x86001e

    49 #define CTHUMBNAILMANAGERIMPL_VALIDATEPRIORITY 0x86001f

    50 #define DUP1_CTHUMBNAILMANAGERIMPL_VALIDATEPRIORITY 0x860020

    51 

    52 

    53 #ifndef __KERNEL_MODE__

    54 #ifndef __OSTTRACEGEN3_TUINT32_CONST_TDESC16REF_TINT_TINT__

    55 #define __OSTTRACEGEN3_TUINT32_CONST_TDESC16REF_TINT_TINT__

    56 

    57 inline TBool OstTraceGen3( TUint32 aTraceID, const TDesC16& aParam1, TInt aParam2, TInt aParam3 )

    58     {

    59     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

    60     if ( retval )

    61         {

    62         TInt length = 0;

    63         // Check that parameter lenght is not too long

    64         TInt length1 = aParam1.Size();

    65         if ((length + length1 + sizeof ( TUint32 )) > KOstMaxDataLength)

    66             {

    67             length1 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

    68             }

    69         TInt lengthAligned1 = ( length1 + 3 ) & ~3;

    70         if (lengthAligned1 > 0)

    71             {

    72             length = length + sizeof ( TUint32 ) + lengthAligned1;

    73             }

    74         TUint8 data[ KOstMaxDataLength ];

    75         TUint8* ptr = data;

    76         // Set length to zero and calculate it againg

    77         // when adding parameters

    78         length = 0;

    79         if (length1 > 0)

    80             {

    81             // Number of elements is written before data

    82             // In case of Unicode string, number of elements is half of length

    83             *( ( TUint32* )ptr ) = length1 / (aParam1.Size() / aParam1.Length());

    84             ptr += sizeof ( TUint32 );

    85             memcpy( ptr, aParam1.Ptr(), length1 );

    86             ptr += length1;

    87             // Fillers are written to get 32-bit alignment

    88             while ( length1++ < lengthAligned1 )

    89                 {

    90                 *ptr++ = 0;

    91                 }

    92             length += sizeof ( TUint32 ) + lengthAligned1;

    93             }

    94         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

    95             {

    96             *( ( TUint32* )ptr ) = 0;

    97             ptr += sizeof ( TUint32 );

    98             length += sizeof ( TUint32 );

    99             }

   100         // Check that there are enough space to next parameter

   101         if ((length + sizeof ( TInt )) <= KOstMaxDataLength)

   102             {

   103             *( ( TInt* )ptr ) = aParam2;

   104             ptr += sizeof ( TInt );

   105             length += sizeof ( TInt );

   106             }

   107         // Check that there are enough space to next parameter

   108         if ((length + sizeof ( TInt )) <= KOstMaxDataLength)

   109             {

   110             *( ( TInt* )ptr ) = aParam3;

   111             ptr += sizeof ( TInt );

   112             length += sizeof ( TInt );

   113             }

   114         ptr -= length;

   115         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, length );

   116         }

   117     return retval;

   118     }

   119 

   120 #endif // __OSTTRACEGEN3_TUINT32_CONST_TDESC16REF_TINT_TINT__

   121 

   122 

   123 #ifndef __OSTTRACEGEN3_TUINT32_CONST_TDESC16REF_TINT32_TINT32__

   124 #define __OSTTRACEGEN3_TUINT32_CONST_TDESC16REF_TINT32_TINT32__

   125 

   126 inline TBool OstTraceGen3( TUint32 aTraceID, const TDesC16& aParam1, TInt32 aParam2, TInt32 aParam3 )

   127     {

   128     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

   129     if ( retval )

   130         {

   131         TInt length = 0;

   132         // Check that parameter lenght is not too long

   133         TInt length1 = aParam1.Size();

   134         if ((length + length1 + sizeof ( TUint32 )) > KOstMaxDataLength)

   135             {

   136             length1 = KOstMaxDataLength - (length + sizeof ( TUint32 ));

   137             }

   138         TInt lengthAligned1 = ( length1 + 3 ) & ~3;

   139         if (lengthAligned1 > 0)

   140             {

   141             length = length + sizeof ( TUint32 ) + lengthAligned1;

   142             }

   143         TUint8 data[ KOstMaxDataLength ];

   144         TUint8* ptr = data;

   145         // Set length to zero and calculate it againg

   146         // when adding parameters

   147         length = 0;

   148         if (length1 > 0)

   149             {

   150             // Number of elements is written before data

   151             // In case of Unicode string, number of elements is half of length

   152             *( ( TUint32* )ptr ) = length1 / (aParam1.Size() / aParam1.Length());

   153             ptr += sizeof ( TUint32 );

   154             memcpy( ptr, aParam1.Ptr(), length1 );

   155             ptr += length1;

   156             // Fillers are written to get 32-bit alignment

   157             while ( length1++ < lengthAligned1 )

   158                 {

   159                 *ptr++ = 0;

   160                 }

   161             length += sizeof ( TUint32 ) + lengthAligned1;

   162             }

   163         else if (length + sizeof ( TUint32 ) <= KOstMaxDataLength)

   164             {

   165             *( ( TUint32* )ptr ) = 0;

   166             ptr += sizeof ( TUint32 );

   167             length += sizeof ( TUint32 );

   168             }

   169         // Check that there are enough space to next parameter

   170         if ((length + sizeof ( TInt )) <= KOstMaxDataLength)

   171             {

   172             *( ( TInt* )ptr ) = aParam2;

   173             ptr += sizeof ( TInt );

   174             length += sizeof ( TInt );

   175             }

   176         // Check that there are enough space to next parameter

   177         if ((length + sizeof ( TInt )) <= KOstMaxDataLength)

   178             {

   179             *( ( TInt* )ptr ) = aParam3;

   180             ptr += sizeof ( TInt );

   181             length += sizeof ( TInt );

   182             }

   183         ptr -= length;

   184         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, length );

   185         }

   186     return retval;

   187     }

   188 

   189 #endif // __OSTTRACEGEN3_TUINT32_CONST_TDESC16REF_TINT32_TINT32__

   190 

   191 #endif

   192 

   193 

   194 #ifndef __OSTTRACEGEN3_TUINT32_TUINT_TUINT_TUINT__

   195 #define __OSTTRACEGEN3_TUINT32_TUINT_TUINT_TUINT__

   196 

   197 inline TBool OstTraceGen3( TUint32 aTraceID, TUint aParam1, TUint aParam2, TUint aParam3 )

   198     {

   199     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

   200     if ( retval )

   201         {

   202         TUint8 data[ 12 ];

   203         TUint8* ptr = data;

   204         *( ( TUint* )ptr ) = aParam1;

   205         ptr += sizeof ( TUint );

   206         *( ( TUint* )ptr ) = aParam2;

   207         ptr += sizeof ( TUint );

   208         *( ( TUint* )ptr ) = aParam3;

   209         ptr += sizeof ( TUint );

   210         ptr -= 12;

   211         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 12 );

   212         }

   213     return retval;

   214     }

   215 

   216 #endif // __OSTTRACEGEN3_TUINT32_TUINT_TUINT_TUINT__

   217 

   218 

   219 #ifndef __OSTTRACEGEN3_TUINT32_TUINT32_TUINT32_TUINT32__

   220 #define __OSTTRACEGEN3_TUINT32_TUINT32_TUINT32_TUINT32__

   221 

   222 inline TBool OstTraceGen3( TUint32 aTraceID, TUint32 aParam1, TUint32 aParam2, TUint32 aParam3 )

   223     {

   224     TBool retval = BTraceFiltered8( EXTRACT_GROUP_ID(aTraceID), EOstTraceActivationQuery, KOstTraceComponentID, aTraceID );

   225     if ( retval )

   226         {

   227         TUint8 data[ 12 ];

   228         TUint8* ptr = data;

   229         *( ( TUint* )ptr ) = aParam1;

   230         ptr += sizeof ( TUint );

   231         *( ( TUint* )ptr ) = aParam2;

   232         ptr += sizeof ( TUint );

   233         *( ( TUint* )ptr ) = aParam3;

   234         ptr += sizeof ( TUint );

   235         ptr -= 12;

   236         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, 12 );

   237         }

   238     return retval;

   239     }

   240 

   241 #endif // __OSTTRACEGEN3_TUINT32_TUINT32_TUINT32_TUINT32__

   242 

   243 

   244 

   245 #ifndef __KERNEL_MODE__

   246 #ifndef __OSTTRACEGEN1_TUINT32_CONST_TDESC16REF__

   247 #define __OSTTRACEGEN1_TUINT32_CONST_TDESC16REF__

   248 

   249 inline TBool OstTraceGen1( TUint32 aTraceID, const TDesC16& aParam1 )

   250     {

   251     TBool retval;

   252     TInt size = aParam1.Size();

   253     // BTrace assumes that parameter size is atleast 4 bytes

   254     if (size % 4 == 0)

   255         {

   256         TUint8* ptr = ( TUint8* )aParam1.Ptr();

   257         // Data is written directly and length is determined from trace message length

   258         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

   259         }

   260     else

   261         {

   262         TUint8 data[ KOstMaxDataLength ];

   263         TUint8* ptr = data;

   264         if (size > KOstMaxDataLength)

   265             {

   266             size = KOstMaxDataLength;

   267             }

   268         TInt sizeAligned = ( size + 3 ) & ~3;

   269         memcpy( ptr, aParam1.Ptr(), size );

   270         ptr += size;

   271         // Fillers are written to get 32-bit alignment

   272         while ( size++ < sizeAligned )

   273             {

   274             *ptr++ = 0;

   275             }

   276         ptr -= sizeAligned;

   277         size = sizeAligned;

   278         // Data is written directly and length is determined from trace message length

   279         retval = OstSendNBytes( EXTRACT_GROUP_ID(aTraceID), EOstTrace, KOstTraceComponentID, aTraceID, ptr, size );

   280         }

   281     return retval;

   282     }

   283 

   284 #endif // __OSTTRACEGEN1_TUINT32_CONST_TDESC16REF__

   285 

   286 #endif

   287 

   288 

   289 #endif

   290 

   291 // End of file

   292