diff -r 8e12a575a9b5 -r 15296fd0af4a sysperfana/heapanalyser/Libraries/UI/HeapUiLib/Controls/HeapCellViewerControl.cs --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sysperfana/heapanalyser/Libraries/UI/HeapUiLib/Controls/HeapCellViewerControl.cs Tue Jun 15 12:47:20 2010 +0300 @@ -0,0 +1,263 @@ +/* +* 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.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Data; +using System.Text; +using System.Windows.Forms; +using HeapLib.Cells; +using HeapLib.Relationships; + +namespace HeapUiLib.Controls +{ + public partial class HeapCellViewerControl : UserControl + { + #region Events + public delegate void OnCellLinkDoubleClicked( HeapCell aCell ); + public event OnCellLinkDoubleClicked CellLinkDoubleClicked; + #endregion + + #region Constructors & destructor + public HeapCellViewerControl() + { + InitializeComponent(); + } + #endregion + + #region Properties + [Browsable(false)] + public HeapCell Cell + { + get { return iCell; } + set + { + // This will asynchronously redraw the table + iCell = value; + DisplayRawDataItemIndex = 0; + } + } + #endregion + + #region Event handlers + private void iTimerRefresh_Tick( object sender, EventArgs e ) + { + iTimerRefresh.Enabled = false; + iTimerRefresh.Stop(); + // + UpdateTable(); + } + + private void iTable_RawItems_CellDoubleClick( object sender, XPTable.Events.CellMouseEventArgs e ) + { + if ( e.Cell.Tag != null && e.Cell.Tag is HeapCell ) + { + HeapCell linkedCell = (HeapCell) e.Cell.Tag; + // + if ( CellLinkDoubleClicked != null ) + { + CellLinkDoubleClicked( linkedCell ); + } + } + } + + private void iButton_PageUp_Click( object sender, EventArgs e ) + { + HeapCell selectedCell = Cell; + if ( selectedCell != null ) + { + DisplayRawDataItemIndex -= KNumberOfRowsPerPage; + } + } + + private void iButton_PageDown_Click( object sender, EventArgs e ) + { + HeapCell selectedCell = Cell; + if ( selectedCell != null ) + { + DisplayRawDataItemIndex += KNumberOfRowsPerPage; + } + } + #endregion + + #region Internal properties + private int DisplayRawDataItemIndex + { + get { return iDisplayRawDataItemIndex; } + set + { + iDisplayRawDataItemIndex = value; + // + SetPageUpButtonStatus(); + SetPageDownButtonStatus(); + // + RefreshContentsByTimer(); + } + } + #endregion + + #region Internal methods + private void UpdateTable() + { + HeapCell cell = Cell; + // + iTable_RawItems.BeginUpdate(); + iTableModel.Rows.Clear(); + // + if ( cell != null ) + { + // Work out our raw item offset and how many raw items to create in this operation + SymbianUtils.RawItems.RawItemCollection rawItems = cell.RawItems; + int rawItemIndexStart = DisplayRawDataItemIndex; + int rawItemIndexEnd = Math.Min( rawItems.Count, rawItemIndexStart + KNumberOfRowsPerPage ); + // + for ( int rawItemIndex = rawItemIndexStart; rawItemIndex < rawItemIndexEnd; rawItemIndex++ ) + { + SymbianUtils.RawItems.RawItem rawEntry = rawItems[ rawItemIndex ]; + XPTable.Models.Row row = new XPTable.Models.Row(); + + // Cell 1: address + XPTable.Models.Cell cellAddress = new XPTable.Models.Cell( rawEntry.Address.ToString( "x8" ) ); + + // Cell 2: raw data + XPTable.Models.Cell cellRawData = new XPTable.Models.Cell( rawEntry.OriginalData.ToString( "x8" ) ); + + // Cell 3: interpreted data + XPTable.Models.Cell cellInterpretedData = new XPTable.Models.Cell( rawEntry.Data.ToString( "x8" ) ); + + // Cell 4: characterised data + XPTable.Models.Cell cellCharacterisedData = new XPTable.Models.Cell( rawEntry.OriginalCharacterisedData ); + + // Update style of "interpreted data" if there is a link to another cell. + RelationshipInfo relationshipDescriptor = ( rawEntry.Tag != null && rawEntry.Tag is RelationshipInfo ) ? (RelationshipInfo) rawEntry.Tag : null; + if ( relationshipDescriptor != null ) + { + // The colour depends on whether it is a clean link or not. Clean means whether or not the + // link points to the start of the specified cell. + HeapCell linkedCell = relationshipDescriptor.ToCell; + // + if ( relationshipDescriptor.IsCleanLink ) + { + cellInterpretedData.ForeColor = Color.Blue; + cellInterpretedData.ToolTipText = "Link to start of: " + linkedCell.SymbolString + " @ 0x" + linkedCell.Address.ToString( "x8" ); + } + else + { + cellInterpretedData.ForeColor = Color.DarkBlue; + cellInterpretedData.ToolTipText = "Link within: " + linkedCell.SymbolString + " @ 0x" + linkedCell.Address.ToString( "x8" ); + } + + cellInterpretedData.Font = new Font( iTable_RawItems.Font, FontStyle.Underline ); + cellInterpretedData.Tag = linkedCell; + } + + // Finish construction + row.Cells.Add( cellAddress ); + row.Cells.Add( cellRawData ); + row.Cells.Add( cellInterpretedData ); + row.Cells.Add( cellCharacterisedData ); + iTableModel.Rows.Add( row ); + } + } + + // Try to select first item + if ( iTable_RawItems.TableModel.Rows.Count > 0 ) + { + iTable_RawItems.EnsureVisible( 0, 0 ); + iTable_RawItems.TableModel.Selections.SelectCell( 0, 0 ); + } + + iTable_RawItems.EndUpdate(); + } + + private void RefreshContentsByTimer() + { + if ( iTimerRefresh.Enabled ) + { + iTimerRefresh.Enabled = false; + iTimerRefresh.Stop(); + } + + iTimerRefresh.Enabled = true; + iTimerRefresh.Start(); + } + + private void SetPageUpButtonStatus() + { + bool enabled = false; + HeapCell selectedCell = Cell; + if ( selectedCell != null ) + { + SymbianUtils.RawItems.RawItemCollection rawItems = selectedCell.RawItems; + // + int previousWindowStart = DisplayRawDataItemIndex - KNumberOfRowsPerPage; + int previousWindowEnd = DisplayRawDataItemIndex; + // + enabled = ( previousWindowStart >= 0 ); + } + iButton_PageUp.Enabled = enabled; + } + + private void SetPageDownButtonStatus() + { + bool enabled = false; + HeapCell selectedCell = Cell; + if ( selectedCell != null ) + { + SymbianUtils.RawItems.RawItemCollection rawItems = selectedCell.RawItems; + // + int nextWindowStart = DisplayRawDataItemIndex + KNumberOfRowsPerPage; + int nextWindowEnd = Math.Min( rawItems.Count, nextWindowStart + KNumberOfRowsPerPage ); + // + enabled = ( nextWindowStart < rawItems.Count ); + } + iButton_PageDown.Enabled = enabled; + } + #endregion + + #region Internal constants + private const int KNumberOfRowsPerPage = 128; + #endregion + + #region Data members + private HeapCell iCell = new HeapCell(); + private int iDisplayRawDataItemIndex = 0; + #endregion + } +}