--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sysperfana/heapanalyser/Libraries/UI/HeapCtrlLib/Controls/HeapDataControl.cs Tue Jun 15 12:47:20 2010 +0300
@@ -0,0 +1,347 @@
+/*
+* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* - Redistributions of source code must retain the above copyright notice,
+* this list of conditions and the following disclaimer.
+* - Redistributions in binary form must reproduce the above copyright notice,
+* this list of conditions and the following disclaimer in the documentation
+* and/or other materials provided with the distribution.
+* - Neither the name of Nokia Corporation nor the names of its contributors
+* may be used to endorse or promote products derived from this software
+* without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+* POSSIBILITY OF SUCH DAMAGE.
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Drawing;
+using System.Data;
+using System.Windows.Forms;
+using HeapLib.Cells;
+using HeapLib.Reconstructor;
+using HeapCtrlLib.Renderers;
+using HeapCtrlLib.Types;
+using HeapLib;
+using HeapLib.Array;
+using SymbianUtils.RawItems;
+
+namespace HeapCtrlLib
+{
+ public class HeapDataControl : System.Windows.Forms.UserControl
+ {
+ #region Delegates & events
+ public delegate void OnCellSelected( HeapCell aCell );
+ public event OnCellSelected CellSelected;
+ public delegate void OnCellDoubleClicked( HeapCell aCell );
+ public event OnCellDoubleClicked CellDoubleClicked;
+ public delegate void CellRightClickedHandler( HeapCell aCell, RawItem aRawItem, Point aScreenPos );
+ public event CellRightClickedHandler CellRightClicked;
+ #endregion
+
+ #region Windows Form Designer code
+ private System.ComponentModel.Container components = null;
+ private HeapCtrlLib.Renderers.HeapDataRenderer iRenderer = null;
+ private SymbianUtilsUi.Controls.ScrollBarWithoutKeyConsumption iSB_Vertical = null;
+ #endregion
+
+ #region Constructors & destructor
+ public HeapDataControl()
+ {
+ InitializeComponent();
+ //
+ // this.SetStyle(ControlStyles.DoubleBuffer, true);
+ // this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
+ // this.SetStyle(ControlStyles.UserPaint, true);
+ this.SetStyle(ControlStyles.ResizeRedraw, true);
+ }
+
+ protected override void Dispose( bool disposing )
+ {
+ if( disposing )
+ {
+ if(components != null)
+ {
+ components.Dispose();
+ }
+ }
+ base.Dispose( disposing );
+ }
+ #endregion
+
+ #region Component Designer generated code
+ private void InitializeComponent()
+ {
+ this.iRenderer = new HeapDataRenderer();
+ this.iSB_Vertical = new SymbianUtilsUi.Controls.ScrollBarWithoutKeyConsumption();
+ this.SuspendLayout();
+ //
+ // iSB_Vertical
+ //
+ this.iSB_Vertical.Dock = System.Windows.Forms.DockStyle.Right;
+ this.iSB_Vertical.Location = new System.Drawing.Point( 598, 2 );
+ this.iSB_Vertical.Name = "iSB_Vertical";
+ this.iSB_Vertical.Size = new System.Drawing.Size( 16, 156 );
+ this.iSB_Vertical.TabIndex = 2;
+ this.iSB_Vertical.Scroll += new System.Windows.Forms.ScrollEventHandler( this.iSB_Vertical_Scroll );
+ //
+ // iRenderer
+ //
+ this.iRenderer.Address = ( (uint) ( 0u ) );
+ this.iRenderer.Anchor = ( (System.Windows.Forms.AnchorStyles) ( ( ( ( System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom )
+ | System.Windows.Forms.AnchorStyles.Left )
+ | System.Windows.Forms.AnchorStyles.Right ) ) );
+ this.iRenderer.FocusedCell = null;
+ this.iRenderer.Location = new System.Drawing.Point( 3, 3 );
+ this.iRenderer.Name = "iRenderer";
+ this.iRenderer.Reconstructor = null;
+ this.iRenderer.Size = new System.Drawing.Size( 596, 154 );
+ this.iRenderer.TabIndex = 1;
+ this.iRenderer.Zoom = HeapCtrlLib.Types.THeapCtrlZoom.EHeapCtrlZoomMedium;
+ this.iRenderer.Enter += new System.EventHandler( this.iRenderer_Enter );
+ this.iRenderer.AddressChanged += new HeapCtrlLib.Renderers.HeapDataRenderer.AddressChangeHandler( this.iRenderer_AddressChanged );
+ this.iRenderer.Leave += new System.EventHandler( this.iRenderer_Leave );
+ this.iRenderer.CellSelected += new HeapCtrlLib.Renderers.HeapDataRenderer.CellSelectionHandler( this.iRenderer_CellSelected );
+ this.iRenderer.CellRightClicked += new HeapDataRenderer.CellRightClickedHandler( iRenderer_CellRightClicked );
+ this.iRenderer.CellDoubleClicked += new HeapDataRenderer.CellDoubleClickHandler( iRenderer_CellDoubleClicked );
+ //
+ // HeapDataControl
+ //
+ this.Controls.Add( this.iSB_Vertical );
+ this.Controls.Add( this.iRenderer );
+ this.Name = "HeapDataControl";
+ this.Padding = new System.Windows.Forms.Padding( 2 );
+ this.Size = new System.Drawing.Size( 616, 160 );
+ this.SizeChanged += new System.EventHandler( this.HeapDataControl_SizeChanged );
+ this.ResumeLayout( false );
+ }
+ #endregion
+
+ #region API
+ public void SetupFilters()
+ {
+ iRenderer.SetupFilters();
+ }
+
+ public void BreadcrumbsChanged()
+ {
+ iRenderer.Invalidate();
+ }
+ #endregion
+
+ #region Properties
+ public THeapCtrlZoom Zoom
+ {
+ get { return iRenderer.Zoom; }
+ set
+ {
+ iRenderer.Zoom = value;
+
+ // Force repositioning to top of view.
+ Reconstructor = Reconstructor;
+ }
+ }
+
+ public THeapCtrlRenderingType Type
+ {
+ get { return iType; }
+ set
+ {
+ if ( iType != value )
+ {
+ iType = value;
+ iRenderer.LoadTypeSet( iType );
+ iRenderer.Invalidate();
+ }
+ }
+ }
+
+ [Browsable(false)]
+ internal Size CellBoxSize
+ {
+ get { return iRenderer.CellBoxSize; }
+ set { iRenderer.CellBoxSize = value; }
+ }
+
+ [Browsable(false)]
+ internal Size CellPadding
+ {
+ get { return iRenderer.CellPadding; }
+ set { iRenderer.CellPadding = value; }
+ }
+
+ [Browsable(false)]
+ public HeapReconstructor Reconstructor
+ {
+ get
+ {
+ return iReconstructor;
+ }
+ set
+ {
+ iReconstructor = value;
+ iRenderer.Reconstructor = value;
+ SetupScrollBar();
+ //
+ Invalidate();
+ }
+ }
+
+ [Browsable(false)]
+ public HeapCell FocusedCell
+ {
+ get { return iRenderer.FocusedCell; }
+ set { iRenderer.FocusedCell = value; }
+ }
+
+ [Browsable(false)]
+ public bool SupportsFiltering
+ {
+ get { return iRenderer.SupportsFiltering; }
+ }
+
+ [Browsable( false )]
+ public HeapCellArrayBase BreadcrumbCellsOutgoing
+ {
+ get { return iRenderer.BreadcrumbCellsOutgoing; }
+ }
+
+ [Browsable( false )]
+ public HeapCellArrayBase BreadcrumbCellsIncoming
+ {
+ get { return iRenderer.BreadcrumbCellsIncoming; }
+ }
+ #endregion
+
+ #region Drawing
+ protected override void OnPaint( PaintEventArgs aArgs )
+ {
+ aArgs.Graphics.Clear( Color.LightGray );
+ //
+ float borderWidth = ( iRenderer.Focused ? 2.0f : 1.0f );
+ Color borderColor = ( iRenderer.Focused ? Color.Black : Color.Gray );
+
+ using( Pen borderPen = new Pen( borderColor, borderWidth ) )
+ {
+ aArgs.Graphics.DrawRectangle( borderPen, 0, 0, ClientSize.Width-1, ClientSize.Height-1 );
+ }
+ //
+ base.OnPaint( aArgs );
+ }
+ #endregion
+
+ #region Event handlers
+ private void HeapDataControl_SizeChanged(object sender, System.EventArgs e)
+ {
+ SetupScrollBar();
+ }
+
+ private void iSB_Vertical_Scroll(object sender, System.Windows.Forms.ScrollEventArgs e)
+ {
+ int rowIndex = e.NewValue;
+ int bytesPerRow = iRenderer.RowsAndColumns.Width * 4;
+ uint baseAddressOffset = (uint) ( bytesPerRow * rowIndex );
+ uint address = iReconstructor.Statistics.HeapAddressStart + baseAddressOffset;
+ //
+ iRenderer.Address = address ;
+ }
+
+ private void iRenderer_AddressChanged( uint aAddressOld, uint aAddressNew, HeapLib.Cells.HeapCell aFirstCell, int aFirstCellIndex )
+ {
+ SetupScrollBar();
+ }
+
+ private void iRenderer_Enter(object sender, System.EventArgs e)
+ {
+ Invalidate();
+ }
+
+ private void iRenderer_Leave(object sender, System.EventArgs e)
+ {
+ Invalidate();
+ }
+
+ private void iRenderer_CellSelected(HeapLib.Cells.HeapCell aCell)
+ {
+ if ( CellSelected != null )
+ {
+ CellSelected( aCell );
+ }
+ }
+
+ private void iRenderer_CellDoubleClicked( HeapCell aCell )
+ {
+ if ( CellDoubleClicked != null )
+ {
+ CellDoubleClicked( aCell );
+ }
+ }
+
+ private void iRenderer_CellRightClicked( HeapCell aCell, RawItem aRawItem, Point aViewerPos )
+ {
+ if ( CellRightClicked != null )
+ {
+ Point screenPos = iRenderer.PointToScreen( aViewerPos );
+ CellRightClicked( aCell, aRawItem, screenPos );
+ }
+ }
+
+ /*protected override void WndProc(ref Message m)
+ {
+ SymbianUtilsUi.Utilities.WindowMessages.PrintMessage( "CTRL ", m.Msg );
+ base.WndProc (ref m);
+ }*/
+ #endregion
+
+ #region Internal methods
+ private void SetupScrollBar()
+ {
+ Size rendererDimensions = iRenderer.RowsAndColumns;
+ //
+ if ( iReconstructor != null && rendererDimensions.Width > 0 && rendererDimensions.Height > 0 )
+ {
+ uint extent = ( iReconstructor.Statistics.HeapAddressEnd - iReconstructor.Statistics.HeapAddressStart );
+ uint bytesPerRow = (uint) ( iRenderer.RowsAndColumns.Width * 4 );
+ uint numberOfRows = extent / bytesPerRow;
+ uint rowNumber = ( iRenderer.Address - iReconstructor.Statistics.HeapAddressStart ) / bytesPerRow;
+ if ( rowNumber > numberOfRows )
+ {
+ rowNumber = numberOfRows;
+ }
+ //
+ iSB_Vertical.Minimum = 0;
+ iSB_Vertical.Maximum = (int) Math.Max( 0, numberOfRows );
+ iSB_Vertical.Value = (int) rowNumber;
+ }
+ }
+ #endregion
+
+ #region Data members
+ private HeapReconstructor iReconstructor;
+ private THeapCtrlRenderingType iType = THeapCtrlRenderingType.EHeapCtrlRenderingTypeByCell;
+ #endregion
+ }
+}