--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/crashanalysercmd/PerfToolsSharedLibraries/Engine/SymbianUtils/TextUtilities/Writers/AsyncTextWriters.cs Thu Feb 11 15:50:58 2010 +0200
@@ -0,0 +1,881 @@
+/*
+* Copyright (c) 2009 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:
+*
+*/
+using System;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Collections;
+using System.Drawing;
+
+namespace SymbianUtils
+{
+ #region Enumerations
+ public enum TNotUsingThread
+ {
+ ENotUsingThread
+ }
+ #endregion
+
+ public abstract class AsyncTextWriterBase : DisposableObject
+ {
+ #region Events
+ public enum TEvent
+ {
+ EWritingStarted = 0,
+ EWritingProgress,
+ EWritingComplete
+ }
+
+ public delegate void Observer( TEvent aEvent, AsyncTextWriterBase aObject );
+ public event Observer iObserver;
+ #endregion
+
+ #region Construct & destruct
+ public AsyncTextWriterBase()
+ : this( System.Threading.ThreadPriority.BelowNormal )
+ {
+ }
+
+ public AsyncTextWriterBase( System.Threading.ThreadPriority aPriority )
+ {
+ iWorkerThread = new Thread( new System.Threading.ThreadStart( WorkerThreadFunction ) );
+ iWorkerThread.Name = "WorkerThreadFunction_" + this.ToString();
+ iWorkerThread.Priority = aPriority;
+ iWorkerThread.IsBackground = true;
+ }
+
+ public AsyncTextWriterBase( TNotUsingThread aNotUsingThread )
+ {
+ }
+ #endregion
+
+ #region API
+ public void AsyncWrite()
+ {
+ lock( this )
+ {
+ if ( iWorkerThread != null )
+ {
+ iWorkerThread.Start();
+ }
+ }
+ }
+ #endregion
+
+ #region From DisposableObject - Cleanup Framework
+ protected override void CleanupManagedResources()
+ {
+ try
+ {
+ }
+ finally
+ {
+ base.CleanupManagedResources();
+ }
+ }
+
+ protected override void CleanupUnmanagedResources()
+ {
+ try
+ {
+ }
+ finally
+ {
+ base.CleanupUnmanagedResources();
+ }
+ }
+ #endregion
+
+ #region Properties
+ public bool IsReady
+ {
+ get
+ {
+ lock(this)
+ {
+ return iReady;
+ }
+ }
+ set
+ {
+ lock( this )
+ {
+ iReady = value;
+ }
+ }
+ }
+
+ public int Progress
+ {
+ get
+ {
+ lock(this)
+ {
+ if (Size == 0)
+ return 0;
+ else
+ {
+ float positionAsFloat = (float)Position;
+ float sizeAsFloat = (float)Size;
+ int progress = (int)((positionAsFloat / sizeAsFloat) * 100.0);
+ //
+ return System.Math.Max(1, System.Math.Min(100, progress));
+ }
+ }
+ }
+ }
+ #endregion
+
+ #region Write handlers
+ protected virtual bool ContinueProcessing()
+ {
+ return false;
+ }
+
+ protected virtual void HandleWriteStarted()
+ {
+ }
+
+ protected virtual void HandleWriteCompleted()
+ {
+ }
+
+ protected virtual void HandleWriteException( Exception aException )
+ {
+ }
+ #endregion
+
+ #region Abstract writing framework
+ public abstract void ExportData();
+ public abstract long Size { get; }
+ public abstract long Position { get; }
+ #endregion
+
+ #region Internal methods
+ private void NotifyEvent( TEvent aEvent )
+ {
+ if ( iObserver != null )
+ {
+ iObserver( aEvent, this );
+ }
+ }
+
+ private void AsyncWriteLines()
+ {
+ bool forcedContinue = false;
+ lock( this )
+ {
+ forcedContinue = ContinueProcessing();
+ }
+
+ while( Progress != KAllWorkCompletedPercentage || forcedContinue )
+ {
+ ExportData();
+
+ lock( this )
+ {
+ NotifyEvent( TEvent.EWritingProgress );
+ forcedContinue = ContinueProcessing();
+ }
+ }
+ }
+
+ private void WorkerThreadFunction()
+ {
+ try
+ {
+ lock( this )
+ {
+ iReady = false;
+ HandleWriteStarted();
+ NotifyEvent( TEvent.EWritingStarted );
+ }
+
+ AsyncWriteLines();
+ }
+ catch( Exception exception )
+ {
+ lock( this )
+ {
+ HandleWriteException( exception );
+ }
+ }
+ finally
+ {
+ lock( this )
+ {
+ HandleWriteCompleted();
+ iReady = true;
+ NotifyEvent( TEvent.EWritingComplete );
+ }
+ }
+ }
+ #endregion
+
+ #region Internal constants
+ protected const int KAllWorkCompletedPercentage = 100;
+ #endregion
+
+ #region Data members
+ protected bool iReady = true;
+ private readonly Thread iWorkerThread;
+ #endregion
+ }
+
+ public abstract class AsyncTextFileWriter : AsyncTextWriterBase
+ {
+ #region Construct & destruct
+ public AsyncTextFileWriter( string aFileName )
+ {
+ iSourceFileName = aFileName;
+ }
+
+ public AsyncTextFileWriter( string aFileName, TNotUsingThread aNotUsingThread )
+ : this( aNotUsingThread )
+ {
+ iSourceFileName = aFileName;
+ }
+
+ public AsyncTextFileWriter( TNotUsingThread aNotUsingThread )
+ : base( aNotUsingThread )
+ {
+ }
+ #endregion
+
+ #region API
+ public void ConstructWriter()
+ {
+ iWriter = new StreamWriter( FileName );
+ }
+
+ public void WriteLine( string aLine )
+ {
+ iWriter.WriteLine( aLine );
+ }
+ #endregion
+
+ #region Properties
+ public StreamWriter Writer
+ {
+ get { return iWriter; }
+ }
+
+ public string FileName
+ {
+ get { return iSourceFileName; }
+ }
+ #endregion
+
+ #region From DisposableObject - Cleanup Framework
+ protected override void CleanupManagedResources()
+ {
+ try
+ {
+ Cleanup();
+ }
+ finally
+ {
+ base.CleanupManagedResources();
+ }
+ }
+ #endregion
+
+ #region From AsyncTextWriterBase
+ protected override void HandleWriteStarted()
+ {
+ if ( iWriter == null )
+ {
+ ConstructWriter();
+ }
+
+ base.HandleWriteStarted();
+ }
+
+ protected override void HandleWriteCompleted()
+ {
+ try
+ {
+ Cleanup();
+ }
+ finally
+ {
+ base.HandleWriteCompleted();
+ }
+ }
+ #endregion
+
+ #region Internal methods
+ private void Cleanup()
+ {
+ lock( this )
+ {
+ if ( iWriter != null )
+ {
+ iWriter.Close();
+ iWriter = null;
+ }
+ }
+ }
+ #endregion
+
+ #region Data members
+ private StreamWriter iWriter;
+ private readonly string iSourceFileName;
+ #endregion
+ }
+
+ public abstract class AsyncHTMLFileWriter : AsyncTextFileWriter
+ {
+ #region Construct & destruct
+ public AsyncHTMLFileWriter( string aFileName )
+ : base( aFileName )
+ {
+ }
+
+ public AsyncHTMLFileWriter( TNotUsingThread aNotUsingThread )
+ : base( aNotUsingThread )
+ {
+ }
+
+ public AsyncHTMLFileWriter( string aFileName, TNotUsingThread aNotUsingThread )
+ : base( aFileName )
+ {
+ }
+ #endregion
+
+ #region Enumerations
+ public enum TAlignment
+ {
+ EAlignNone = -1,
+ EAlignLeft = 0,
+ EAlignRight,
+ EAlignCenter,
+ EAlignJustify
+ }
+ #endregion
+
+ #region Helper methods - document
+ public void WriteDocumentBegin()
+ {
+ WriteLine( "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\">" );
+ WriteLine( "<HTML>" );
+ }
+
+ public void WriteDocumentEnd()
+ {
+ WriteLine( "</HTML>" );
+ }
+ #endregion
+
+ #region Helper methods - header
+ public void WriteHeadBegin()
+ {
+ WriteLine( "<HEAD>" );
+ }
+
+ public void WriteHeadEnd()
+ {
+ Writer.WriteLine( "</HEAD>" );
+ }
+
+ public void WriteTitle( string aTitle )
+ {
+ Writer.WriteLine( "<TITLE>" + aTitle + "</TITLE>" );
+ }
+
+ public void WriteStyleBegin()
+ {
+ WriteLine( "<META HTTP-EQUIV=\"Content-Style-Type\" CONTENT=\"text/css\">" );
+ WriteLine( "<STYLE TYPE=\"text/css\" MEDIA=\"screen, print, projection\">" );
+ }
+
+ public void WriteStyleName( string aName )
+ {
+ WriteLine( aName );
+ }
+
+ public void WriteStyleBodyBegin()
+ {
+ WriteLine( "{" );
+ }
+
+ public void WriteStyleBody( string aStyle )
+ {
+ WriteLine( " " + aStyle );
+ }
+
+ public void WriteStyleBodyEnd()
+ {
+ WriteLine( "}" );
+ }
+
+ public void WriteStyleEnd()
+ {
+ Writer.WriteLine( "</STYLE>" );
+ }
+ #endregion
+
+ #region Helper methods - body
+ public void WriteBodyBegin()
+ {
+ WriteLine( "<BODY>" );
+ }
+
+ public void WriteBodyEnd()
+ {
+ WriteLine( "</BODY>" );
+ }
+ #endregion
+
+ #region Helper methods - tables
+ public void WriteTableBegin()
+ {
+ WriteTableBegin( 100 );
+ }
+
+ public void WriteTableBegin( int aWidthPercentage )
+ {
+ WriteLine( "<TABLE WIDTH=\"" + aWidthPercentage.ToString() + "%\">" );
+ }
+
+ public void WriteTableBeginWidthPixels( int aWidthPixels, Color aColor )
+ {
+ string color = ColorString( aColor );
+ WriteLine( "<TABLE WIDTH=\"" + aWidthPixels.ToString() + "px\" bgcolor=\"" + color + "\">" );
+ }
+
+ public void WriteTableEnd()
+ {
+ Writer.WriteLine( "</TABLE>" );
+ }
+
+ public void WriteTableRowBegin()
+ {
+ WriteLine( "<TR>" );
+ }
+
+ public void WriteTableRowEnd()
+ {
+ WriteLine( "</TR>" );
+ }
+
+ public void WriteTableColumnBegin()
+ {
+ WriteTableColumnBegin( TAlignment.EAlignNone, string.Empty );
+ }
+
+ public void WriteTableColumnBegin( TAlignment aAlignment, string aStyle )
+ {
+ WriteTableColumnBegin( aAlignment, aStyle, -1 );
+ }
+
+ public void WriteTableColumnBegin( TAlignment aAlignment, string aStyle, int aPixelWidth )
+ {
+ StringBuilder line = new StringBuilder();
+ line.Append( "<TD" );
+ line.Append( FormattedClass( aStyle ) );
+ line.Append( FormattedAlignment( aAlignment ) );
+ line.Append( FormattedWidthPixel( aPixelWidth ) );
+ line.Append( ">" );
+ WriteLine( line.ToString() );
+ }
+
+ public void WriteTableColumnEnd()
+ {
+ WriteLine( "</TD>" );
+ }
+
+ public void WriteTableColumn( string aValue )
+ {
+ WriteTableColumn( aValue, TAlignment.EAlignNone, string.Empty );
+ }
+
+ public void WriteTableColumn( string aValue, TAlignment aAlignment )
+ {
+ WriteTableColumn( aValue, aAlignment, string.Empty );
+ }
+
+ public void WriteTableColumn( string aValue, string aStyle )
+ {
+ WriteTableColumn( aValue, TAlignment.EAlignNone, aStyle );
+ }
+
+ public void WriteTableColumn( string aValue, TAlignment aAlignment, string aStyle )
+ {
+ WriteTableColumnBegin( aAlignment, aStyle );
+ Writer.Write( aValue );
+ WriteTableColumnEnd();
+ }
+
+ public void WriteTableColumnFormatted( long aNumber, string aFormat )
+ {
+ WriteTableColumnFormatted( aNumber, aFormat, TAlignment.EAlignNone );
+ }
+
+ public void WriteTableColumnFormatted( long aNumber, string aFormat, TAlignment aAlignment )
+ {
+ WriteTableColumnFormatted( aNumber, aFormat, aAlignment, string.Empty );
+ }
+
+ public void WriteTableColumnFormatted( long aNumber, string aFormat, TAlignment aAlignment, string aStyle )
+ {
+ WriteTableColumn( aNumber.ToString( aFormat ), aAlignment, aStyle );
+ }
+
+ public void WriteTableColumn( long aNumber )
+ {
+ WriteTableColumn( aNumber, "d" );
+ }
+
+ public void WriteTableColumn( long aNumber, string aStyle )
+ {
+ WriteTableColumnFormatted( aNumber, "d", TAlignment.EAlignNone, aStyle );
+ }
+
+ public void WriteTableColumn( long aNumber, TAlignment aAlignment )
+ {
+ WriteTableColumnFormatted( aNumber, "d", aAlignment, string.Empty );
+ }
+
+ public void WriteTableColumn( long aNumber, TAlignment aAlignment, string aStyle )
+ {
+ WriteTableColumnFormatted( aNumber, "d", aAlignment, aStyle );
+ }
+
+ public void WriteTableColumnHex( long aNumber )
+ {
+ WriteTableColumnHex( aNumber, string.Empty );
+ }
+
+ public void WriteTableColumnHex( long aNumber, string aStyle )
+ {
+ WriteTableColumnHex( aNumber, TAlignment.EAlignNone, aStyle );
+ }
+
+ public void WriteTableColumnHex( long aNumber, TAlignment aAlignment, string aStyle )
+ {
+ WriteTableColumn( aNumber.ToString( "x8" ), aAlignment, aStyle );
+ }
+
+ public void WriteTableColumnHexAddress( long aNumber )
+ {
+ WriteTableColumnHexAddress( aNumber, TAlignment.EAlignNone );
+ }
+
+ public void WriteTableColumnHexAddress( long aNumber, TAlignment aAlignment )
+ {
+ WriteTableColumnHexAddress( aNumber, aAlignment, string.Empty );
+ }
+
+ public void WriteTableColumnHexAddress( long aNumber, TAlignment aAlignment, string aStyle )
+ {
+ WriteTableColumn( "0x" + aNumber.ToString( "x8" ), aAlignment, aStyle );
+ }
+
+ public void WriteTableColumnSpace()
+ {
+ WriteTableColumnBegin();
+ WriteLine( " " );
+ WriteTableColumnEnd();
+ }
+
+ public void WriteTableColumnSpace( int aPixelWidth )
+ {
+ WriteTableColumnBegin();
+ WriteLine( " " );
+ WriteTableColumnEnd();
+ }
+
+ public void WriteTableColumnEmpty()
+ {
+ WriteTableColumnBegin();
+ WriteTableColumnEnd();
+ }
+ #endregion
+
+ #region Helper methods - blocks/paragraphs
+ public void WriteDivisionBegin()
+ {
+ WriteLine( "<DIV>" );
+ }
+
+ public void WriteDivisionBegin( string aStyle )
+ {
+ WriteDivisionBegin( TAlignment.EAlignNone, aStyle );
+ }
+
+ public void WriteDivisionBeginWithId( string aId )
+ {
+ WriteDivisionBegin( TAlignment.EAlignNone, string.Empty, aId );
+ }
+
+ public void WriteDivisionBegin( TAlignment aAlignment )
+ {
+ WriteDivisionBegin( aAlignment, string.Empty );
+ }
+
+ public void WriteDivisionBegin( TAlignment aAlignment, string aStyle )
+ {
+ WriteDivisionBegin( aAlignment, aStyle, string.Empty );
+ }
+
+ public void WriteDivisionBegin( TAlignment aAlignment, string aStyle, string aId )
+ {
+ StringBuilder line = new StringBuilder();
+ line.Append( "<DIV" );
+ line.Append( FormattedClass( aStyle ) );
+ line.Append( FormattedAlignment( aAlignment ) );
+ line.Append( FormattedId( aId ) );
+ line.Append( ">" );
+ //
+ WriteLine( line.ToString() );
+ }
+
+ public void WriteDivisionEnd()
+ {
+ WriteLine( "</DIV>" );
+ }
+
+ public void WriteParagraphBegin()
+ {
+ WriteLine( "<P>" );
+ }
+
+ public void WriteParagraphBegin( string aClass )
+ {
+ WriteLine( "<P CLASS=\"" + aClass + "\">" );
+ }
+
+ public void WriteParagraphEnd()
+ {
+ WriteLine( "</P>" );
+ }
+
+ public void WriteSpanBegin()
+ {
+ WriteSpanBegin( string.Empty );
+ }
+
+ public void WriteSpanBegin( string aClass )
+ {
+ WriteSpanBegin( aClass, string.Empty );
+ }
+
+ public void WriteSpanBegin( string aClass, string aId )
+ {
+ Writer.Write( "<SPAN" );
+ Writer.Write( FormattedClass( aClass ) );
+ Writer.Write( FormattedId( aId ) );
+ Writer.Write( ">" );
+ }
+
+ public void WriteSpanEnd()
+ {
+ WriteLine( "</SPAN>" );
+ }
+
+ public void WriteNewLine()
+ {
+ WriteLine( "<BR>" );
+ }
+ #endregion
+
+ #region Helper methods - text
+ public void WriteText( string aText )
+ {
+ Writer.Write( aText );
+ }
+
+ public void WriteText( string aText, string aStyle )
+ {
+ Writer.Write( "<SPAN CLASS=\"" + aStyle + "\">" );
+ Writer.Write( aText );
+ Writer.Write( "</SPAN>" );
+ }
+
+ public void WriteLine( string aText, string aStyle )
+ {
+ StringBuilder line = new StringBuilder();
+ //
+ line.Append( "<SPAN CLASS=\"" + aStyle + "\">" );
+ line.Append( aText );
+ line.Append( "</SPAN>" );
+ //
+ WriteLine( line.ToString() );
+ }
+
+ public void WriteSpace()
+ {
+ Writer.Write( " " );
+ }
+ #endregion
+
+ #region Helper methods - links (anchors)
+ public void WriteAnchorBegin( string aPageAddress )
+ {
+ WriteAnchorBeginWithStyle( aPageAddress, string.Empty );
+ }
+
+ public void WriteAnchorBeginWithStyle( string aPageAddress, string aStyle )
+ {
+ StringBuilder line = new StringBuilder();
+ line.Append( "<A " );
+ line.Append( FormattedClass( aStyle ) );
+ line.Append( "HREF=\"" );
+ line.Append( aPageAddress );
+ line.Append( "\"" );
+ //
+ line.Append( ">" );
+ Writer.Write( line.ToString() );
+ }
+
+ public void WriteAnchorEnd()
+ {
+ WriteLine( "</A>" );
+ }
+
+ public void WriteAnchorWithName( string aName )
+ {
+ WriteAnchorWithName( aName, string.Empty );
+ }
+
+ public void WriteAnchorWithName( string aName, string aValue )
+ {
+ StringBuilder line = new StringBuilder();
+ line.Append( "<A " );
+ line.Append( "NAME=\"#" );
+ line.Append( aName );
+ line.Append( "\"" );
+ line.Append( ">" );
+ line.Append( aValue );
+ line.Append( "</A>" );
+ Writer.Write( line.ToString() );
+ }
+
+ public void WriteAnchorWithTarget( string aTargetName, string aURL, string aText )
+ {
+ StringBuilder line = new StringBuilder();
+ line.Append( "<A " );
+ line.Append( "TARGET=\"" );
+ line.Append( aTargetName );
+ line.Append( "\" " );
+ line.Append( "HREF=\"" );
+ line.Append( aURL );
+ line.Append( "\"" );
+ line.Append( ">" );
+ line.Append( aText );
+ line.Append( "</A>" );
+ Writer.Write( line.ToString() );
+ }
+ #endregion
+
+ #region Helper methods - colors
+ public static string ColorString( Color aColor )
+ {
+ StringBuilder ret = new StringBuilder();
+ //
+ ret.Append( "#" );
+ ret.Append( aColor.R.ToString("x2") );
+ ret.Append( aColor.G.ToString("x2") );
+ ret.Append( aColor.B.ToString("x2") );
+ //
+ return ret.ToString();
+ }
+ #endregion
+
+ #region Internal methods
+ static string FormattedId( string aId )
+ {
+ string ret = string.Empty;
+ //
+ if ( aId != string.Empty )
+ {
+ ret = " ID=\"" + aId + "\" ";
+ }
+ //
+ return ret;
+ }
+
+ static string FormattedClass( string aStyleName )
+ {
+ string ret = string.Empty;
+ //
+ if ( aStyleName != string.Empty )
+ {
+ ret = " CLASS=\"" + aStyleName + "\"";
+ }
+ //
+ return ret;
+ }
+
+ static string FormattedWidthPixel( int aWidth )
+ {
+ string ret = string.Empty;
+ //
+ if ( aWidth > 0 )
+ {
+ ret = " WIDTH=\"" + aWidth.ToString() + "px\"";
+ }
+ //
+ return ret;
+ }
+
+ static string FormattedWidthPercent( int aWidth )
+ {
+ string ret = string.Empty;
+ //
+ if ( aWidth > 0 )
+ {
+ ret = " WIDTH=\"" + aWidth.ToString() + "%\"";
+ }
+ //
+ return ret;
+ }
+
+ static string FormattedAlignment( TAlignment aAlignment )
+ {
+ StringBuilder line = new StringBuilder();
+ //
+ if ( aAlignment != TAlignment.EAlignNone )
+ {
+ line.Append( " ALIGN=\"" );
+ switch( aAlignment )
+ {
+ case TAlignment.EAlignLeft:
+ line.Append( "LEFT" );
+ break;
+ case TAlignment.EAlignRight:
+ line.Append( "RIGHT" );
+ break;
+ case TAlignment.EAlignCenter:
+ line.Append( "CENTER" );
+ break;
+ case TAlignment.EAlignJustify:
+ line.Append( "JUSTIFY" );
+ break;
+ default:
+ case TAlignment.EAlignNone:
+ break;
+ }
+ line.Append( "\"" );
+ }
+ //
+ return line.ToString();
+ }
+ #endregion
+ }
+}