/*

* 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;

using HeapLib.Cells;

using HeapLib.Array;

using HeapLib.Relationships;

using HeapLib.Reconstructor;

using HeapCtrlLib.Utilities;

using HeapCtrlLib.Interfaces;

using HeapCtrlLib.Factories;

using HeapCtrlLib.Types;

using SymbianUtils.Range;

using SymbianUtils.RawItems;

namespace HeapCtrlLib.Renderers

{

    internal class HeapDataRenderer : UserControl

    {

        #region Delegates & events

        public delegate void AddressChangeHandler( uint aAddressOld, uint aAddressNew, HeapCell aFirstCell, int aFirstCellIndex );

        public event AddressChangeHandler AddressChanged;

        public delegate void CellSelectionHandler( HeapCell aCell );

        public event CellSelectionHandler CellSelected;

        public delegate void CellDoubleClickHandler( HeapCell aCell );

        public event CellDoubleClickHandler CellDoubleClicked;

        public delegate void CellRightClickedHandler( HeapCell aCell, RawItem aItem, Point aViewerPos );

        public event CellRightClickedHandler CellRightClicked;

        #endregion

        #region Constructors & destructor

        internal HeapDataRenderer()

        {

            InitializeComponent();

            //

            LoadTypeSet( THeapCtrlRenderingType.EHeapCtrlRenderingTypeByCell );

            //

            this.SetStyle( ControlStyles.UserPaint, true );

            this.SetStyle( ControlStyles.DoubleBuffer, true );

            this.SetStyle( ControlStyles.AllPaintingInWmPaint, true );

            this.SetStyle( ControlStyles.ResizeRedraw, true );

            this.SetStyle( ControlStyles.Selectable, true );

            //

            this.MouseWheel += new MouseEventHandler( HeapDataRenderer_MouseWheel );

        }

        protected override void Dispose( bool disposing )

        {

            if  ( disposing )

            {

            }

            base.Dispose( disposing );

        }

        #endregion

        #region Component Designer generated code

        private void InitializeComponent()

        {

            this.iLbl_NoContent = new System.Windows.Forms.Label();

            this.SuspendLayout();

            // 

            // iLbl_NoContent

            // 

            this.iLbl_NoContent.Dock = System.Windows.Forms.DockStyle.Fill;

            this.iLbl_NoContent.Location = new System.Drawing.Point( 0, 0 );

            this.iLbl_NoContent.Name = "iLbl_NoContent";

            this.iLbl_NoContent.Size = new System.Drawing.Size( 600, 408 );

            this.iLbl_NoContent.TabIndex = 0;

            this.iLbl_NoContent.Text = "No Content";

            this.iLbl_NoContent.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;

            // 

            // HeapDataRenderer

            // 

            this.Controls.Add( this.iLbl_NoContent );

            this.DoubleBuffered = true;

            this.Name = "HeapDataRenderer";

            this.Size = new System.Drawing.Size( 600, 408 );

            this.MouseDown += new System.Windows.Forms.MouseEventHandler( this.HeapDataRenderer_MouseDown );

            this.MouseMove += new System.Windows.Forms.MouseEventHandler( this.HeapDataRenderer_MouseMove );

            this.MouseDoubleClick += new System.Windows.Forms.MouseEventHandler( this.HeapDataRenderer_MouseDoubleClick );

            this.MouseLeave += new System.EventHandler( this.HeapDataRenderer_MouseLeave );

            this.MouseUp += new System.Windows.Forms.MouseEventHandler( this.HeapDataRenderer_MouseUp );

            this.KeyDown += new System.Windows.Forms.KeyEventHandler( this.HeapDataRenderer_KeyDown );

            this.ResumeLayout( false );

        }

        #endregion

        #region API

        public void SetupFilters()

        {

            if ( !SupportsFiltering )

            {

                throw new NotSupportedException();

            }

            iFactory.Renderers.Content.SetupFilters();

        }

        public void LoadTypeSet( THeapCtrlRenderingType aType )

        {

            iFactory = HeapCtrlLib.Factories.Factory.CreateByType( aType );

            // Set sizes

            CellBoxSize = iFactory.CellBoxSize( Zoom );

            CellPadding = iFactory.CellPadding( Zoom );

            // Do init.

            InitialiseRenderers();

        }

        public int RowForAddress( uint aAddress )

        {

            uint addressOffset = aAddress - Reconstructor.Statistics.HeapAddressStart;

            uint bytesPerRow = BytesPerRow;

            int row = (int) ( addressOffset / bytesPerRow );

            //System.Diagnostics.Debug.WriteLine( "base: 0x" + Reconstructor.Statistics.HeapAddressStart.ToString("x8") + ", offset: 0x" + addressOffset.ToString("x8") + ", addr: 0x" + aAddress.ToString("x8") + ", row: " + row + ", remainder: " + ( addressOffset % bytesPerRow ) + ", bytesPerRow: " + bytesPerRow );

            //

            return row;

        }

        #endregion

        #region Properties

        public HeapReconstructor Reconstructor

        {

            get

            {

                return iReconstructor;

            }

            set

            {

                iReconstructor = value;

                if  ( iReconstructor != null )

                {

                    iCells = iReconstructor.Data;

                    InitialiseRenderers();

                    if  ( iCells.Count > 0 )

                    {

                        HeapCell cell = Cells[ 0 ];

                        // Must first set the address, or else this messes up

                        // VisibleAddressRange...

                        Address = cell.Address;

                        // ... which is needed by FocusedCell when changing

                        // the focus.

                        FocusedCell = cell;

                    }

                }

            }

        }

        public HeapCellArray Cells

        {

            get

            {

                return iCells;

            }

        }

        public HeapCell FocusedCell

        {

            get

            {

                return iFocusedCellKeyboard;

            }

            set

            {

                iFocusedCellKeyboard = value;

                if  ( iFocusedCellKeyboard != null )

                {

                    uint visRangeMin = (uint) VisibleAddressRange.Min;

                    uint visRangeMax = (uint) VisibleAddressRange.Max - BytesPerRow;

                    // Do we need to move the view?

                    int currentMinRow = RowForAddress( visRangeMin );

                    int row = RowForAddress( value.Address );

                    int currentMaxRow = RowForAddress ( visRangeMax );

                    //

                    //System.Diagnostics.Debug.WriteLine( "row: " + row + ", minR: " + currentMinRow + "(" + visRangeMin.ToString("x8") + "), maxR: " + currentMaxRow + "(" + visRangeMax.ToString("x8") + ")" );

                    //System.Diagnostics.Debug.WriteLine( " " );

                    if  ( row < currentMinRow || row > currentMaxRow )

                    {

                        Address = (uint) ( Reconstructor.Statistics.HeapAddressStart + ( row * BytesPerRow ) );

                    }

                    else

                    {

                        Invalidate();

                    }

                }

                if  ( CellSelected != null )

                {

                    CellSelected( iFocusedCellKeyboard );

                }

            }

        }

        public uint Address

        {

            get { return iCellAddress; }

            set

            {

                this.Enabled = ( value > 0 );

                iLbl_NoContent.Visible = ( value == 0 );

                // Validate

                int index = -1;

                HeapCell cell = Cells.CellByAddress( value, out index );

                if  ( cell != null )

                {

                    iFactory.PopupManager.PopupHide();

                    //

                    iCellIndex = index;

                    uint oldAddress = iCellAddress;

                    iCellAddress = value;

                    iFocusedCellMouse = null;

                    //

                    if  ( AddressChanged != null )

                    {

                        AddressChanged( oldAddress, iCellAddress, cell, iCellIndex );

                    }

                    //

                    Invalidate();

                }

                else if ( value == 0 )

                {

                    // Do nothing, we're disabled

                }

                else

                {

                    // Bad address

                    throw new ArgumentException( "Invalid cell address", "value" );

                }

            }

        }

        public uint BytesPerRow

        {

            get

            {

                uint bytesPerRow = (uint) RowsAndColumns.Width * 4;

                return bytesPerRow;

            }

        }

        public uint BytesPerScreen

        {

            get

            {

                uint bytesPerScreen = BytesPerRow * (uint) RowsAndColumns.Height;

                return bytesPerScreen;

            }

        }

        public THeapCtrlZoom Zoom

        {

            get { return iZoom; }

            set

            {

                if ( value != iZoom )

                {

                    // Get base size from factory

                    CellBoxSize = iFactory.CellBoxSize( value );

                    CellPadding = iFactory.CellPadding( value );

                }

                //

                iZoom = value;

            }

        }

        public AddressRange VisibleAddressRange

        {

            get

            {

                AddressRange range = new AddressRange();

                //

                range.UpdateMin( Address );

                range.UpdateMax( Address + BytesPerScreen );

                //

                return range;

            }

        }

        public bool SupportsFiltering

        {

            get { return iFactory.Renderers.Content.SupportsFiltering; }

        }

        public HeapCellArrayBase BreadcrumbCellsOutgoing

        {

            get { return iBreadcrumbCellsOutgoing; }

            set { iBreadcrumbCellsOutgoing = new HeapCellArrayUnsorted( value ); }

        }

        public HeapCellArrayBase BreadcrumbCellsIncoming

        {

            get { return iBreadcrumbCellsIncoming; }

            set { iBreadcrumbCellsIncoming = new HeapCellArrayUnsorted( value ); }

        }

        internal Factory Factory

        {

            get { return iFactory; }

        }

        #endregion

        #region Co-ordinate mapping

        public Point AddressToPixelCoordinate( uint aAddress )

        {

            Point ret = new Point( 0, 0 );

            //

            Size overallPaddingSize = RowsAndColumnsRemainingPixels;

            Size rowAndColumnDimensions = RowsAndColumns;

            // First, work out how many boxes would be required to draw

            // the specific cell address

            long delta = ((long) aAddress - (long) iCellAddress);

            // This can be a negative number

            int boxesForDelta = (int) ( delta / KDWordSize );

            // Then work out how many rows and columns would be needed to reach

            // that value.

            Point numberOfRowsAndColumns = new Point( 0, 0 );

            if ( delta > 0 )

            {

                // Going forwards from current top left of view port.

                numberOfRowsAndColumns.Y = ( boxesForDelta / rowAndColumnDimensions.Width );

                numberOfRowsAndColumns.X = ( boxesForDelta - ( numberOfRowsAndColumns.Y * rowAndColumnDimensions.Width ) );

            }

            else

            {

                numberOfRowsAndColumns.Y = ( boxesForDelta / rowAndColumnDimensions.Width ) - 1;

                numberOfRowsAndColumns.X = Math.Abs( ( numberOfRowsAndColumns.Y * rowAndColumnDimensions.Width ) - boxesForDelta );

            }

            // Work our pixel pos

            ret.X = numberOfRowsAndColumns.X * CellBoxSizeIncludingPadding.Width;

            ret.Y = numberOfRowsAndColumns.Y * CellBoxSizeIncludingPadding.Height;

            // And take into account padding and header size

            ret.X += CellBoxRect.X;

            ret.Y += CellBoxRect.Y;

            //

            return ret;

        }

        public Point CoordinateToBox( Point aPixelPos )

        {

            Point ret = new Point( -1, -1 );

            //

            Size rowsAndColumns = RowsAndColumns;

            if  ( CellBoxRect.Contains( aPixelPos ) )

            {

                Size overallPaddingSize = RowsAndColumnsRemainingPixels;

                // Work out which row this event occurs within.

                int row = ( aPixelPos.Y - ( overallPaddingSize.Height / 2 ) ) / CellBoxSizeIncludingPadding.Height;

                if  ( row >= 0 && row < rowsAndColumns.Height )

                {

                    // Work out the column index for that cell.

                    int xpos = aPixelPos.X - ( overallPaddingSize.Width / 2 ) - CellAddressHeaderSize.Width;

                    // How many boxes could we have rendered for that xpos

                    int boxCount = ( xpos / CellBoxSizeIncludingPadding.Width );

                    ret.X = boxCount;

                    ret.Y = row;

                }

            }

            //System.Diagnostics.Debug.WriteLine( "aPixelPos[ " + aPixelPos.X + ", " + aPixelPos.Y + " ], boxPos: [ " + ret.X + ", " + ret.Y + " ]" );

            //

            return ret;

        }

        public Point BoxCoordinateByAddress( uint aAddress )

        {

            Point ret = new Point( -1, -1 );

            // First, work out how many boxes would be required to draw

            // the specific cell address

            uint delta = aAddress - iCellAddress;

            int boxesForDelta = (int) ( delta / KDWordSize );

            // Then work out how many rows & columns would need to be

            // drawn to reach that value.

            Size rowAndColumnDimensions = RowsAndColumns;

            ret.Y = boxesForDelta / rowAndColumnDimensions.Width;

            ret.X = boxesForDelta - ( ret.Y * rowAndColumnDimensions.Width );

            //

            return ret;

        }

        public uint AddressByBoxCoordinates( Point aBoxCoordinates )

        {

            uint ret = iCellAddress;

            //

            if  ( Cells.Count > 0 && aBoxCoordinates.X >= 0 && aBoxCoordinates.Y >= 0 )

            {

                Size rowsAndColumns = RowsAndColumns;

                //

                ret += (uint) ( aBoxCoordinates.Y * KDWordSize * rowsAndColumns.Width );

                ret += (uint) ( aBoxCoordinates.X * KDWordSize );

            }

            //

            return ret;

        }

        public uint AddressByCoordinate( Point aPixelPos )

        {

            Point boxPos = CoordinateToBox( aPixelPos );

            uint ret = AddressByBoxCoordinates( boxPos );

            return ret;

        }

        public RawItem RawItemByPixelPos( Point aPixelPos )

        {

            RawItem ret = null;

            //

            Point boxPos = CoordinateToBox( aPixelPos );

            HeapCell cell = CellByBoxCoordinates( boxPos );

            //

            if ( cell != null )

            {

                uint rawItemAddress = AddressByBoxCoordinates( boxPos );

                HeapCell.TRegion region = cell.RegionForAddress( rawItemAddress );

                // We only provide raw items for payload sections

                if ( region == HeapCell.TRegion.EPayload )

                {

                    ret = cell[ rawItemAddress ];

                }

            }

            //

            return ret;

        }

        public HeapCell CellByPosition( Point aPixelPos )

        {

            HeapCell ret = null;

            //

            Point boxPos = CoordinateToBox( aPixelPos );

            if  ( Cells.Count > 0 && boxPos.X >= 0 && boxPos.Y >= 0 )

            {

                ret = CellByBoxCoordinates( boxPos );

            }

            //

            return ret;

        }

        public HeapCell CellByBoxCoordinates( Point aBoxCoordinates )

        {

            uint address = AddressByBoxCoordinates( aBoxCoordinates );

            HeapCell ret = Cells.CellByAddress( address );

            return ret;

        }

        public int CellIndex( HeapCell aCell )

        {

            int index = -1;

            Cells.CellByExactAddress( aCell.Address, out index );

            return index;

        }

        #endregion

        #region Sizing

        internal Rectangle CellBoxRect

        {

            get

            {

                Size overallPaddingSize = RowsAndColumnsRemainingPixels;

                Size bodySize = RowsAndColumnsInPixels;

                //

                Rectangle ret = new Rectangle();

                ret.X = ( overallPaddingSize.Width / 2 ) + CellAddressHeaderSize.Width;

                ret.Y = overallPaddingSize.Height / 2;

                ret.Width = bodySize.Width;

                ret.Height = bodySize.Height;

                //

                return ret;

            }

        }

        [Browsable(false)]