InventoryGrid.c

Go to the documentation of this file.

// -----------------------------------------------------------
class InventoryGridController extends ScriptedWidgetEventHandler
{
    void OnItemEnter(InventoryGrid grid, Widget w, int row, int col) {}
    void OnItemLeave(InventoryGrid grid, Widget w) {}
    void OnItemDrag(InventoryGrid grid, Widget w, int row, int col) {}
    void OnItemDraggingOver(InventoryGrid grid, Widget w, int row, int col) {}
    void OnItemDrop(InventoryGrid grid, Widget w, int row, int col) {}
    void OnItemDropReceived(InventoryGrid grid, Widget w, int row, int col) {}
    void OnItemClick(InventoryGrid grid, Widget w, int row, int col) {}
    void OnItemLeftClick(InventoryGrid grid, Widget w, int row, int col) {}
    void OnItemRightClick(InventoryGrid grid, Widget w, int row, int col) {}
    void OnItemDoubleClick(InventoryGrid grid, Widget w, int row, int col) {}
    // float GetItemQuantity(InventoryGrid grid, InventoryItem item) {}
    int GetItemColor(ScriptedWidgetEventHandler grid, InventoryItem item)
    { 
        return 0;
    }
    int GetQuickbarItemColor(InventoryGrid grid, InventoryItem item) {}
    vector GetItemSize(InventoryGrid grid, InventoryItem item)
    {
        return Vector(0, 1, 1);
    }
    string GetItemQuantityText( InventoryItem item ) {}
    int HasItemQuantity( InventoryItem item ) {}
    float GetItemQuantity( InventoryItem item ) {}
    int GetItemQuantityMax( InventoryItem item ) {}
    int GetItemCount( InventoryItem item ) {}
    bool CanAddItemInHandToInventory() {}
};
 
// -----------------------------------------------------------
typedef map<InventoryItem, vector> TItemsMap
 
class InventoryGrid extends ScriptedWidgetEventHandler
{
    // AARRGGBB
    static int ITEM_COLOR_QUICKBAR_NORMAL   = 0x0AFFFFFF;
    static int ITEM_COLOR_QUICKBAR_H_GOOD   = 0x2A6e980d;
    static int ITEM_COLOR_QUICKBAR_H_BAD    = 0x2A980d0d;
    static int ITEM_COLOR_QUICKBAR_I_BAD    = 0x2A986e0d;
    static int ITEM_COLOR_NORMAL            = 0x0AFFFFFF;
    static int ITEM_COLOR_DRAG              = 0x0AFFFFFF;
    
    reference bool                      m_IsDebugOutput;
 
    protected ref map<int, Widget>      m_BackgroundWidgets;
    protected ref map<int, Widget>      m_ItemWidgets;
    protected ref TItemsMap             m_Items;
    protected InventoryGridController   m_Controller;
 
    
    protected Widget                    m_Root;
    protected int                       m_GridSize;
    protected bool                      m_IsMouseLeftDown;
    protected bool                      m_CanAddItemInHandToInventory;
 
    void InventoryGrid()
    {
        m_Items             = new TItemsMap;    
        m_BackgroundWidgets = new map<int, Widget>;
        m_ItemWidgets       = new map<int, Widget>;
    }
 
    protected void OnWidgetScriptInit(Widget w)
    {
        m_Root = w;
        m_Root.SetHandler(this);
    }
    
    // NOTE: This is a cached value, depending on when it is called it might not be 100% accurate
    bool CanAddItemInHandToInventory()
    {
        return m_CanAddItemInHandToInventory;
    }
    
    // ScriptedWidgetEventHandler override
    override bool OnUpdate(Widget w)
    {
        return false;
    }
    
    // -----------------------------------------------------------
    override bool OnMouseEnter(Widget w, int x, int y)
    {
        int col = GetCol( w );
        
        if ( !IsValidPos( col ) )
            return false;   
        
        if (m_IsDebugOutput)
        {
            PrintString (m_Root.GetName() + "::OnMouseEnter(" + col.ToString() + ")");
        }
        
        if (m_Controller) m_Controller.OnItemEnter(this, w, 0, col);
    
        return true;
    }
    
    // -----------------------------------------------------------
    override bool OnMouseLeave(Widget w, Widget enterW, int x, int y)
    {
        if (m_Controller) m_Controller.OnItemLeave(this, w);
    
        return true;
    }
    
    // -----------------------------------------------------------
    override bool OnMouseButtonDown(Widget w, int x, int y, int button)
    {
        if (button == MouseState.RIGHT || button == MouseState.LEFT)
        {
            int col = GetCol( w );
        
            if ( !IsValidPos( col ) )
                return false;
            
            if (m_IsDebugOutput)
            {
                PrintString (m_Root.GetName() + "::OnMouseButtonDown(" + col.ToString() + ")");
            }
        
            if (m_Controller) 
            {
                if (button == MouseState.RIGHT )
                {
                    m_Controller.OnItemRightClick(this, w, 0, col);
                }
 
                if (button == MouseState.LEFT )
                {
                    m_IsMouseLeftDown = true;
                }
            }
            return true;
        }
        else
        {
            return false;
        }
    }
 
    // -----------------------------------------------------------
    override bool OnMouseButtonUp(Widget w, int x, int y, int button)
    {
        if ( button == MouseState.LEFT )
        {
            if( m_IsMouseLeftDown )
            {
                m_Controller.OnItemLeftClick(this, w, 0, m_col);
                m_IsMouseLeftDown = false;
            }
        }
 
        if (button == MouseState.RIGHT || button == MouseState.LEFT)
        {
            int col = GetCol( w );
        
            if ( !IsValidPos( col ) )
                return false;
            
            if (m_IsDebugOutput)
            {
                PrintString (m_Root.GetName() + "::OnMouseButtonUp(" + col.ToString() + ")");
            }
        
            return true;
        }
        else
        {
            return false;
        }
    }
    
    // -----------------------------------------------------------
    override bool OnDoubleClick(Widget w, int x, int y, int button)
    {
        if (button != MouseState.LEFT) return false;
        
        int col = GetCol( w );
    
        if ( !IsValidPos( col ) )
                return false;
        
        if (m_IsDebugOutput)
        {
            PrintString (m_Root.GetName() + "::OnDoubleClick(" + col.ToString() + ")");
        }
    
        if (m_Controller) m_Controller.OnItemDoubleClick(this, w, 0, col);
    
        return true;
    }
    
    //--------------------------------------------------------------------------
    override bool OnDrop(Widget w, int x, int y, Widget reciever)
    {
        if (m_IsDebugOutput)
        {
            PrintString (m_Root.GetName() + "::OnDrop()");
        }
    
        if (m_Controller) 
        {
            m_Controller.OnItemDrop(this, w, 0, m_col);
        }
        
        if (w)
        {
            ItemPreviewWidget item_preview = ItemPreviewWidget.Cast( w.FindAnyWidget("Preview") );
            if (item_preview)
            {
                item_preview.SetView( item_preview.GetItem().GetViewIndex() );
            }
        }
        
        return true;
    }
    
    int GetCol( Widget w )
    {
        int index;
        
        if( m_ItemWidgets.GetKeyByValueChecked( w, index ) )
            return index;
        else if( m_BackgroundWidgets.GetKeyByValueChecked( w, index ) )
            return index;
        else
            return -1;
    }
    
    int GetColFromBg( Widget w )
    {
        return m_BackgroundWidgets.GetKeyByValue( w );
    }
    
    int GetGridSize()
    {
        return m_GridSize;
    }
    
    void SetGridSize( int size )
    {
        m_GridSize = size;
        for( int i = 0; i < m_BackgroundWidgets.Count(); i++ )
        {
            if( i < size )
            {
                m_BackgroundWidgets.Get( i ).Show( true );
            }
            else
            {
                m_BackgroundWidgets.Get( i ).Show( false );
            }
        }
    }
    
    bool IsValidPos( int index )
    {
        return ( m_GridSize > index && index > -1 );
    }
    
    private Widget m_on_drag_item;
    private int m_col;
    
    //--------------------------------------------------------------------------
    override bool OnDrag(Widget w, int x, int y)
    {
        w.SetPos(x, y);
 
        m_col = GetCol( w );
        
        if ( !IsValidPos( m_col ) )
            return false;
        
        if (m_IsDebugOutput)
        {
            PrintString (m_Root.GetName() + "::OnDrag(" + m_col.ToString() + ")");
        }
    
        if (m_Controller) m_Controller.OnItemDrag(this, w, 0, m_col);
    
        ItemPreviewWidget item_preview = ItemPreviewWidget.Cast( w.FindAnyWidget("Preview") );
        if (item_preview)
        {
            item_preview.SetView( item_preview.GetItem().GetViewIndex() );
        }
        return true;
    }
    
    //--------------------------------------------------------------------------
    override bool OnDraggingOver(Widget w, int x, int y, Widget reciever)
    {
        int col = GetCol( reciever );
        
        if ( !IsValidPos( col ) )
        {
            return false;
        }
        
        if (m_IsDebugOutput)
        {
            PrintString (m_Root.GetName() + "::OnDraggingOver(" + col.ToString() + ")");
        }
    
        if (m_Controller) m_Controller.OnItemDraggingOver(this, w, 0, col);
    
        
        return true;
    }
    
    //--------------------------------------------------------------------------
    override bool OnDropReceived(Widget w, int x, int y, Widget reciever)
    {
        int col = GetCol( reciever );
    
        if ( !IsValidPos( col ) )
            return false;
        
        if (m_IsDebugOutput)
        {
            PrintString (m_Root.GetName() + "::OnDropReceived(" + col.ToString() + ")");
        }
    
        if (m_Controller) m_Controller.OnItemDropReceived(this, w, 0, col);
    
        
        return true;
    }
    
    TItemsMap GetItems() {
        return m_Items; 
    }
    
    //--------------------------------------------------------------------------
    Widget GetItem(int index)
    {
        if( m_ItemWidgets.Contains( index ) )
            return m_ItemWidgets.Get( index );
        else
            return null;
    }
    
    //--------------------------------------------------------------------------
    Widget GetItemBackground(int index)
    {
        if( m_BackgroundWidgets.Contains( index ) )
            return m_BackgroundWidgets.Get( index );
        else
            return null;
    }
 
    Widget GetRoot()
    {
        return m_Root;
    }
    
    void SetItemColor(InventoryItem item, int color)
    {
        if (m_Items.Contains(item))
        {
            vector data = m_Items.Get(item);
            int index = Math.Round(data[0]);
            
            Widget w = GetItem(index);
            if (w)
                w.SetColor(color);
        }
    }
    
    void SetController(InventoryGridController controller) { 
        m_Controller = controller; 
    }
 
    InventoryGridController GetController() { 
        return m_Controller; 
    }
    
    //--------------------------------------------------------------------------
    void GenerateQuickBarBackgroundTiles(int count)
    {
        for (int i = 0; i < count; i++)
        {
            Widget root_widget = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory/inventoryGridBackground.layout", m_Root);
            TextWidget label_widget = TextWidget.Cast( root_widget.FindAnyWidget( "Label1" ) );
            TextWidget label_widget2 = TextWidget.Cast( root_widget.FindAnyWidget( "Label2" ) );
            label_widget.SetText( (i+1).ToString() );
            label_widget2.SetText( (i+1).ToString() );
            m_BackgroundWidgets.Insert( i, root_widget );
        }
    }
    
    //--------------------------------------------------------------------------
    void UpdateQuickbarItems( TItemsMap items )
    {
        int i;
        int c;
        int index;
        int width;
        int height;
        int row;
        int col;
        InventoryItem item;
        vector data;
        Widget bck;
        Widget item_w;
        
        // remove not actual items
        c = m_Items.Count();
        for (i = 0; i < c; i++)
        {
            item = m_Items.GetKey(i);
            if( item != NULL )
            {
                bool remove_item = false;
                
                if (items.Contains(item) == false)
                {
                    remove_item = true;
                }
                else
                {
                    // check items position actual
                    if ((m_Items.Get(item) - items.Get(item)).LengthSq() > 0.01)
                    {
                        // item has different position or size
                        remove_item = true;
                    }
                }
                
                if (remove_item)
                {
                    RemoveItem(item);
                    c--;
                    i--;            
                }
            }
        }
        
        // add new items
        for (i = 0; i < items.Count(); i++)
        {
            item = items.GetKey(i);
            data = items.Get(item);
                    
            if (m_Items.Contains(item) == false)
            {
                AddItem(item, data, Vector(0,0,0) );
            }
        }
        
        // cache if entity in hands can be added to inventory
        m_CanAddItemInHandToInventory = m_Controller.CanAddItemInHandToInventory();
    
        // refresh quickbar
        for (i = 0; i < items.Count(); i++)
        {
            item = items.GetKey(i);
            data = items.Get(item);
            RefreshQuickbarItemVariables( item, data );
        }
    }
    
    
    //--------------------------------------------------------------------------
    void UpdateItems(TItemsMap items, bool show_quantity, bool show_temperature )
    {
        int i;
        int c;
        int index;
        int width;
        int height;
        int row;
        int col;
        InventoryItem item;
        vector data;
        Widget bck;
        Widget item_w;
        
        // remove not actual items
        c = m_Items.Count();
        for (i = 0; i < c; i++)
        {
            item = m_Items.GetKey(i);
            
            bool remove_item = false;
            
            if (items.Contains(item) == false)
            {
                remove_item = true;
            }
            else
            {
                // check items position actual
                if ((m_Items.Get(item) - items.Get(item)).LengthSq() > 0.01)
                {
                    // item has different position or size
                    remove_item = true;
                }
            }
            
            if (remove_item)
            {
                RemoveItem(item);
                c--;
                i--;            
            }
        }
        
        // add new items
        for (i = 0; i < items.Count(); i++)
        {
            item = items.GetKey(i);
            data = items.Get(item);
                    
            if (m_Items.Contains(item) == false)
            {
                AddItem(item, data, Vector(0,0,0) );
            }
        }
    
        // add new items
        for (i = 0; i < items.Count(); i++)
        {
            item = items.GetKey(i);
            data = items.Get(item);
            // refresh quantity
            RefreshItemVariables( item, data, show_quantity, show_temperature );
        }
    }
    
    //--------------------------------------------------------------------------
    void UpdateQuantityItems()
    {
        int i;
        int index;
        InventoryItem item;
        vector data;
        for (i = 0; i < m_Items.Count(); i++)
        {
            item = m_Items.GetKey(i);
            data = m_Items.Get(item); 
            index = Math.Round(data[0]);
            RefreshItemVariables( item, data, true, false );
        }
    }
    
    //--------------------------------------------------------------------------
    void UpdateTemperatureItems()
    {
        int i;
        int index;
        InventoryItem item;
        vector data;
        for (i = 0; i < m_Items.Count(); i++)
        {
            item = m_Items.GetKey(i);
            data = m_Items.Get(item); 
            index = Math.Round(data[0]);
            RefreshItemVariables( item, data, false, true );
        }
    }
    
    //--------------------------------------------------------------------------
    void RefreshQuickbarItemVariables(InventoryItem item, vector data)
    {
        int index = Math.Round(data[0]);
        Widget bck = GetItemBackground(index);
        if ( bck )
        {
            Widget item_w = bck.FindAnyWidget("GridItem");
            if ( item_w )
            {
                int color = m_Controller.GetQuickbarItemColor( this, item ); // !!!!!
                item_w.SetColor( color );
            }
        }
        RefreshItemVariables( item, data, true, false );
    }
    
    //--------------------------------------------------------------------------
    void RefreshItemVariables(InventoryItem item, vector data, bool show_quantity, bool show_temperature )
    {
        int index = Math.Round(data[0]);
        Widget bck = GetItemBackground(index);
        Widget item_w;
    
        if ( bck )
        {
            item_w = bck.FindAnyWidget("GridItem");
            if ( item_w )
            {
                int has_quantity = m_Controller.HasItemQuantity( item );
                Widget quantity_panel = bck.FindAnyWidget("QuantityPanel");
                TextWidget item_quantity = TextWidget.Cast( bck.FindAnyWidget("Quantity") );
                ProgressBarWidget quantity_progress = ProgressBarWidget.Cast( bck.FindAnyWidget("QuantityBar") );
                Widget quantity_stack = bck.FindAnyWidget("QuantityStackPanel");
                if ( has_quantity == QUANTITY_HIDDEN )
                {
                    quantity_panel.Show( false );
                }
                else
                {
                    quantity_panel.Show( true );
                    if ( has_quantity == QUANTITY_COUNT )
                    {
                        item_quantity.SetText( m_Controller.GetItemQuantityText( item ) );
                        quantity_stack.Show( true );
                        quantity_progress.Show( false );
                    }
                    else if ( has_quantity == QUANTITY_PROGRESS )
                    {
                        float progress_max = quantity_progress.GetMax();
                        int max = m_Controller.GetItemQuantityMax( item );
                        int count = m_Controller.GetItemCount( item );
                        float quantity = m_Controller.GetItemQuantity( item );
                        if ( count > 0 )
                        {
                            max = count;
                        }
                        if ( max > 0 )
                        {
    
                            float value = Math.Round( ( quantity / max ) * 100 );
                            quantity_progress.SetCurrent( value );
                        }
                        quantity_stack.Show( false );
                        quantity_progress.Show( true );
                    }
                }
                
                if ( show_temperature )
                {
                    if ( item && item.IsInherited( InventoryItem ) )
                    {
                        int color = m_Controller.GetItemColor( this, item); // !!!!!
                        if ( color )
                        {
                            item_w.SetColor( color );
                        }
                    }
                }
            }
        }
    }
    
    //--------------------------------------------------------------------------
    void AddItem(InventoryItem item, vector data, vector rotation)
    {
        m_Items.Set(item, data);            
                
        int index = Math.Round(data[0]);
        int width = Math.Round(data[1]);
        int height = Math.Round(data[2]);
                
        Widget bck = GetItemBackground(index);
        Widget item_w_bck = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory/inventoryGridItem.layout", bck);
        Widget item_w = item_w_bck.FindAnyWidget("GridItem");
        
        bck.FindAnyWidget("LabelTR").Show( true );
        bck.FindAnyWidget("LabelCC").Show( false );
        
        m_ItemWidgets.Insert( index, item_w );
        
        ResetItemWidget(item_w, width, height);
        
        if ( item )
        {
            ItemPreviewWidget item_preview = ItemPreviewWidget.Cast( item_w.FindAnyWidget("Preview") );
            item_preview.SetItem(item);
            item_preview.SetModelOrientation( rotation );
            item_preview.SetView( item_preview.GetItem().GetViewIndex() );
            
            RefreshItemVariables( item, data, true, true );
        }
    }
 
    //--------------------------------------------------------------------------
    void SetItem(InventoryItem item, vector data, vector rotation)
    {
        m_Items.Set(item, data);
                
        int index = Math.Round(data[0]);
        int width = Math.Round(data[1]);
        int height = Math.Round(data[2]);
                
        Widget bck = GetItemBackground(index);
        Widget item_w_bck = bck.FindAnyWidget("GridItemBck");
        
        if(item_w_bck)
        {
            bck.FindAnyWidget("LabelTR").Show( true );
            bck.FindAnyWidget("LabelCC").Show( false );
            
            Widget item_w = item_w_bck.FindAnyWidget("GridItem");
            ResetItemWidget(item_w, width, height);
            
            if ( item )
            {
                ItemPreviewWidget item_preview = ItemPreviewWidget.Cast( item_w.FindAnyWidget("Preview") );
                item_preview.SetItem(item);
                item_preview.Show( true );
                item_preview.SetModelOrientation( rotation );
                item_preview.SetView( item_preview.GetItem().GetViewIndex() );
                
                RefreshItemVariables( item, data, true, true );
            }
            else
            {
                item_preview = ItemPreviewWidget.Cast( item_w.FindAnyWidget("Preview") );
                item_preview.Show( false );
            }
        }
    }
    
    //--------------------------------------------------------------------------
    protected void ResetItemWidget(Widget item_w, int width, int height)
    {
        if( item_w )
        {
            item_w.SetColor(ITEM_COLOR_NORMAL);
        }
    }
    
    //--------------------------------------------------------------------------
    void ResetItem(InventoryItem item)
    {
        if (m_Items.Contains(item))
        {
            vector data = m_Items.Get(item);
            int index = Math.Round(data[0]);
            int width = Math.Round(data[1]);
            int height = Math.Round(data[2]);
            Widget bck = GetItemBackground(index);
            Widget item_w = bck.FindAnyWidget("GridItem");
            ResetItemWidget(item_w, width, height);
            RefreshItemVariables( item, data, true, true );
        }
    }
    
    //--------------------------------------------------------------------------
    bool HasItem(InventoryItem item)
    {
        return m_Items.Contains(item);
    }
    
    //--------------------------------------------------------------------------
    void RemoveItem(InventoryItem item)
    {
        Widget bck;
        Widget itemW;
        if ( item && m_Items.Contains( item ) )
        {
            vector data = m_Items.Get(item);
            int index = Math.Round(data[0]);
            int width = Math.Round(data[1]);
            int height = Math.Round(data[2]);
            bck = GetItemBackground(index);
            if( bck )
            {
                itemW = bck.FindAnyWidget("GridCell");
                if( itemW )
                    delete itemW;
                bck.FindAnyWidget("LabelTR").Show( false );
                bck.FindAnyWidget("LabelCC").Show( true );
            }
        
            m_Items.Remove( item );
            m_ItemWidgets.Remove( index );
        }
    }
};