diff -r 000000000000 -r 094583676ce7 wvuing/Inc/LayoutDebugPrint.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wvuing/Inc/LayoutDebugPrint.h Thu Dec 17 08:41:52 2009 +0200 @@ -0,0 +1,347 @@ +/* +* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Layout debug print definitions +* +*/ + + +/* +* +* Description: +* +* Logging tools. Uniforms style to write debug data to +* screen using RDebug or to a file with RFileLogger. +* +* Usage: +* 1.Configuring: +* +* Logging and debug printing is configured with following macros +* LAYOUT_ENABLE_DEBUG_PRINT (defining this enables debug printing) +* LAYOUT_DEBUG_OUTPUT_TO_FILE (now debug printing goes to file) +* LAYOUT_DEBUG_FILENAME "Some.log" (file to store debug log) +* +* Debug printing can be configured on project level by defining desired +* macros in .mmp file like this +* //enable file logging +* MACRO LAYOUT_ENABLE_DEBUG_PRINT +* MACRO LAYOUT_DEBUG_OUTPUT_TO_FILE +* +* You may also automate the debug printing to follow current build +* variant like this: +* #ifdef _DEBUG +* MACRO LAYOUT_ENABLE_DEBUG_PRINT +* #endif // _DEBUG +* +* The file to write debug log needs to be defined in file level. +* (Defining it in mmp file causes errors to build procedure..) +* #define LAYOUT_DEBUG_FILENAME "Example.log" +* +* When using debug printing to file, flogger.lib needs to be added in +* mmp file +* LIBRARY flogger.lib +* and following directory must be manually done before loggin +* (no directory, not logs) Epoc32\Wins\c\logs\LAYOUT\ +* +* +* 2.Printing: +* +* // normal string output: +* LAYOUT_DP( D_LAYOUT_LIT("Some text.") ); >> LAYOUT: Some text. +* LAYOUT_DP( D_PLAIN_LIT("Some text.") ); >> Some text. +* LAYOUT_DP_TXT("Some text."); >> LAYOUT: Some text. +* +* // string with variables +* TInt index( 99 ); +* _LIT( KExample, "Example" ); +* LAYOUT_DP( D_LAYOUT_LIT("Some text: %d"), 100 ); >> LAYOUT: Some text: 100 +* LAYOUT_DP( D_LAYOUT_LIT("Some text: %d"), index ); >> LAYOUT: Some text: 99 +* LAYOUT_DP( D_LAYOUT_LIT("Some text: %S"), &KExample ); >> LAYOUT: Some text: Example +* +* LAYOUT_DP( D_PLAIN_LIT("Some text: %d"), 100 ); >> Some text: 100 +* LAYOUT_DP( D_PLAIN_LIT("Some text: %d"), index ); >> Some text: 99 +* LAYOUT_DP( D_PLAIN_LIT("Some text: %S"), &KExample ); >> Some text: Example +* +* +* 3.Known issues: +* +* - If you use macros from .mmp file remember to abld makefile to +* change flags from project. +* - In statements like LAYOUT_DP( D_LAYOUT_LIT("Some text: %S"), &KExample ); +* parameters causes still some code to generated in release builds. +* Propably it is best to #ifdef all debugprint blocks +* with LAYOUT_ENABLE_DEBUG_PRINT statement. +* +* ============================================================================ +*/ + + +#ifndef __LAYOUTDEBUGPRINT_H__ +#define __LAYOUTDEBUGPRINT_H__ + +// Debug logging is enabled, you may enable debug printing in release builds also +#ifdef LAYOUT_ENABLE_DEBUG_PRINT + +// no include files if no debug printing --> faster compile time +// INCLUDES +#include +#include +#include + +#ifndef _DEBUG +// warn in release build!! +#if defined(__VC32__) +#pragma message( "Warning: LAYOUT debug printing is on in release build!" ) // CSI: 68 # Warning for rel builds +#else // __GCC32__ +#warning "LAYOUT debug printing is on in release build!" +#endif // __VC32__ +#endif + +/** + * Depending if the build is UNICODE or not, define the + * helper macros that insert LAYOUT prefix. + */ +#ifdef _UNICODE +#ifndef LAYOUT_DEBUG_OUTPUT_TO_FILE +#define LAYOUT_TOKEN_PASTING( s ) L##s +#define LAYOUT_TO_UNICODE( s ) LAYOUT_TOKEN_PASTING( s ) +#define LAYOUT_DEBUG_STR( m ) LAYOUT_TO_UNICODE( "LAYOUT: " ) L##m +#else +#define LAYOUT_TOKEN_PASTING( s ) L##s +#define LAYOUT_TO_UNICODE( s ) LAYOUT_TOKEN_PASTING( s ) +#define LAYOUT_DEBUG_STR( m ) L##m +#endif +#else +#define LAYOUT_DEBUG_STR "LAYOUT: " +#endif // _UNICODE + + +/** + * Helper macro for defining debug strings with plain debug text. + */ +#define D_LPLAIN_LIT( s ) _L( s ) // CSI: 78 # Debug print + + +/** + * Helper macro for defining debug strings with "LAYOUT:" prefix. + */ +#define D_LAYOUT_LIT( s ) TPtrC( ( const TText * ) LAYOUT_DEBUG_STR( s ) ) + +#ifdef LAYOUT_DEBUG_OUTPUT_TO_FILE + +/** + * Method to handle file writing + */ +inline void LAYOUTDebugWriteFormat( TRefByValue< const TDesC > aFmt, ... ) + { + _LIT( KDir, "Layout" ); +#ifdef LAYOUT_DEBUG_FILENAME + const static TLitC < sizeof( LAYOUT_DEBUG_FILENAME ) > KName = { + sizeof( LAYOUT_DEBUG_FILENAME ) - 1, LAYOUT_TO_UNICODE( + LAYOUT_DEBUG_FILENAME ) + }; +#else + _LIT( KName, "LayoutDebug.log" ); +#endif // LAYOUT_DEBUG_FILENAME + + // take the ellipsis parameters + VA_LIST args; + VA_START( args, aFmt ); + RFileLogger::WriteFormat( KDir, KName, EFileLoggingModeAppend, + aFmt, args ); + VA_END( args ); + } + +/** + * Actual debug printters. + * Output to log file. + */ +#define LAYOUT_DP LAYOUTDebugWriteFormat +#define LAYOUT_DP_TXT( s ) LAYOUTDebugWriteFormat( D_LAYOUT_LIT( s ) ) + + + +#else +/** + * Actual debug printters. + * Output to debugger output. + */ +#define LAYOUT_DP RDebug::Print +#define LAYOUT_DP_TXT( s ) RDebug::Print( D_LAYOUT_LIT( s ) ) +#endif + + +#else //LAYOUT_ENABLE_DEBUG_PRINT + +/** + * + * Empty implementations for non-debug printing build versions. + * + */ + +/** + * Dummy struct for checking that all LAYOUT_DP's define string + * literals using space-saving D_PLAIN_LIT or D_LAYOUT_LIT. + */ +struct TLAYOUTEmptyDebugString { }; + +/** + * Macro for defining debug-only literal strings (empty release version) + */ +#define D_LPLAIN_LIT( s ) TLAYOUTEmptyDebugString() + +/** + * Macro for defining debug-only literal strings (empty release version) + */ +#define D_LAYOUT_LIT( s ) TLAYOUTEmptyDebugString() + +/** + * Macro for empty debug print function + */ +#define LAYOUT_DP_TXT( s ) LAYOUT_DP( D_LAYOUT_LIT( s ) ) + + +/// Empty debug print function for release builds. +inline void LAYOUT_DP( TLAYOUTEmptyDebugString ) + { + } + +template< class T1 > +inline void LAYOUT_DP( TLAYOUTEmptyDebugString, T1 ) + { + } + +template< class T1, class T2 > +inline void LAYOUT_DP( TLAYOUTEmptyDebugString, T1, T2 ) + { + } + +template< class T1, class T2, class T3 > +inline void LAYOUT_DP( TLAYOUTEmptyDebugString, T1, T2, T3 ) + { + } + +template< class T1, class T2, class T3, class T4 > +inline void LAYOUT_DP( TLAYOUTEmptyDebugString, T1, T2, T3, T4 ) + { + } + +template< class T1, class T2, class T3, class T4, class T5 > +inline void LAYOUT_DP( TLAYOUTEmptyDebugString, T1, T2, T3, T4, T5 ) + { + } + +template< class T1, class T2, class T3, class T4, class T5, class T6 > +inline void LAYOUT_DP( TLAYOUTEmptyDebugString, T1, T2, T3, T4, T5, T6 ) + { + } + +template +inline void LAYOUT_DP( TLAYOUTEmptyDebugString, T1, T2, T3, T4, T5, T6, T7 ) + { + } + +template < class T1, class T2, class T3, class T4, class T5, class T6, class T7, +class T8 > +inline void LAYOUT_DP( TLAYOUTEmptyDebugString, T1, T2, T3, T4, T5, T6, T7, T8 ) + { + } + +template < class T1, class T2, class T3, class T4, class T5, class T6, class T7, +class T8, class T9 > +inline void LAYOUT_DP( TLAYOUTEmptyDebugString, T1, T2, T3, T4, T5, T6, T7, T8, T9 ) + { + } + +template < class T1, class T2, class T3, class T4, class T5, class T6, class T7, +class T8, class T9, class T10 > +inline void LAYOUT_DP( TLAYOUTEmptyDebugString, T1, T2, T3, T4, T5, T6, T7, T8, T9, + T10 ) + { + } + +template < class T1, class T2, class T3, class T4, class T5, class T6, class T7, +class T8, class T9, class T10, class T11 > +inline void LAYOUT_DP( TLAYOUTEmptyDebugString, T1, T2, T3, T4, T5, T6, T7, T8, T9, + T10, T11 ) + { + } + +#endif // LAYOUT_ENABLE_DEBUG_PRINT + +/* Some general wrappers to LAYOUT_DP for convenience. + * + * Since these just wrap LAYOUT_DP, they work transparently: the macros write + * stuff to debug output or to a file, whichever you are using, + * you don't have to care. + * + * Since LAYOUT_DP is either defined or empty inline, these won't + * matter in either build (no, there is no noticeable penalty in compile time) + * + * There are three types of wrappers, output format is + * + * "filename:linenumber method - enter" when entering function + * "filename:linenumber method - message" when inside function + * "filename:linenumber method - done" when exiting function + * + * Example: + * TInt CSomeClass::SomeMethod() + * { + * LAYOUT_DP_FUNC_ENTER("SomeMethod"); + * + * TInt i = 41; + * + * LAYOUT_DP_FUNC_DP("SomeMethod", "Doing intensive calculations"); + * + * i++; + * + * LAYOUT_DP_FUNC_DONE("SomeMethod"); + * } + * + * You have to provide the method name yourself since the __FUNCTION__ + * preprocessor macro is not understood. + */ + +#include "ChatDebugMacros.h" // WFILE etc. + +// when entering a function +#define LAYOUT_DP_FUNC_ENTER( method ) \ + LAYOUT_DP( D_LAYOUT_LIT( "%s:%d %s - enter" ), __WFILE__, __LINE__, L ## method ); + +// debug print +#define LAYOUT_DP_FUNC_DP( method,msg ) \ + LAYOUT_DP( D_LAYOUT_LIT( "%s:%d %s - %s" ), __WFILE__, __LINE__, L ## method, L ## msg ); + +// when exiting a function +#define LAYOUT_DP_FUNC_DONE( method ) \ + LAYOUT_DP( D_LAYOUT_LIT( "%s:%d %s - done" ), __WFILE__, __LINE__, L ## method ); + +// Helpper Method to write rect's value +#ifdef LAYOUT_ENABLE_DEBUG_PRINT +#define LAYOUT_DP_RECT( name, rect ) \ + LAYOUT_DP( \ + D_LAYOUT_LIT( "%s: %d,%d;%d,%d (%dx%d)" ), \ + L ## name, \ + rect.iTl.iX, rect.iTl.iY, rect.iBr.iX, rect.iBr.iY, \ + rect.Width(), rect.Height() ); + +#else //LAYOUT_ENABLE_DEBUG_PRINT +#define LAYOUT_DP_RECT( name, rect ) \ + LAYOUT_DP_TXT( "LAYOUT_DP_RECT" ); + +#endif //LAYOUT_ENABLE_DEBUG_PRINT + +#endif // __LAYOUTDEBUGPRINT_H__ + + +// End of File