inspectmenunew.c

Go to the documentation of this file.

//--------------------------------------------------------------------------
class InspectMenuNew extends UIScriptedMenu
{
 private ItemPreviewWidget m_item_widget;
 private ItemPreviewWidget m_slot_widget;
 private int m_characterRotationX;
 private int m_characterRotationY;
 private int m_characterScaleDelta;
 private vector m_characterOrientation;
 
 
 void InspectMenuNew()
 {
 
 }
 
 //--------------------------------------------------------------------------
 void ~InspectMenuNew()
 {
 GetGame().GetDragQueue().RemoveCalls(this);
 if (GetGame().GetMission())
 {
 GetGame().GetMission().GetHud().ShowHudUI( true );
 GetGame().GetMission().GetHud().ShowQuickbarUI( true );
 }
 }
 
 //--------------------------------------------------------------------------
 override Widget Init()
 {
 layoutRoot = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory_new/day_z_inventory_new_inspect.layout");
 
 
 return layoutRoot;
 }
 
 //--------------------------------------------------------------------------
 override bool OnClick(Widget w, int x, int y, int button)
 {
 super.OnClick(w, x, y, button);
 
 switch (w.GetUserID())
 {
 case IDC_CANCEL:
 Close();
 return true;
 }
 
 return false;
 }
 
 //--------------------------------------------------------------------------
 void SetItem(EntityAI item)
 {
 if (item)
 {
 InspectMenuNew.UpdateItemInfo(layoutRoot, item);
 
 if (!m_item_widget)
 {
 Widget preview_frame = layoutRoot.FindAnyWidget("ItemFrameWidget");
 if (preview_frame)
 {
 m_item_widget = ItemPreviewWidget.Cast( preview_frame );
 }
 }
 
 m_item_widget.SetItem(item);
 m_item_widget.SetView( item.GetViewIndex() );
 m_item_widget.SetModelPosition(Vector(0,0,1));
 PPERequesterBank.GetRequester(PPERequester_InventoryBlur).Start();
 }
 }
 
 //--------------------------------------------------------------------------
 override bool OnMouseButtonDown(Widget w, int x, int y, int button)
 {
 super.OnMouseButtonDown(w, x, y, button);
 
 if (w == m_item_widget)
 {
 GetGame().GetDragQueue().Call(this, "UpdateRotation");
 GetMousePos(m_characterRotationX, m_characterRotationY);
 return true;
 }
 return false;
 }
 
 //--------------------------------------------------------------------------
 void UpdateRotation(int mouse_x, int mouse_y, bool is_dragging)
 {
 vector o = m_characterOrientation;
 o[0] = o[0] + (m_characterRotationY - mouse_y);
 o[1] = o[1] - (m_characterRotationX - mouse_x);
 
 m_item_widget.SetModelOrientation( o );
 
 if (!is_dragging)
 {
 m_characterOrientation = o;
 }
 }
 
 //--------------------------------------------------------------------------
 override bool OnMouseWheel(Widget w, int x, int y, int wheel)
 {
 super.OnMouseWheel(w, x, y, wheel);
 
 if ( w == m_item_widget )
 {
 m_characterScaleDelta = wheel;
 UpdateScale();
 }
 return false;
 }
 
 //--------------------------------------------------------------------------
 void UpdateScale()
 {
 float w, h, x, y; 
 m_item_widget.GetPos(x, y);
 m_item_widget.GetSize(w,h);
 w = w + ( m_characterScaleDelta / 4);
 h = h + ( m_characterScaleDelta / 4 );
 if ( w > 0.5 && w < 3 )
 {
 m_item_widget.SetSize( w, h );
 
 // align to center 
 int screen_w, screen_h;
 GetScreenSize(screen_w, screen_h);
 float new_x = x - ( m_characterScaleDelta / 8 );
 float new_y = y - ( m_characterScaleDelta / 8 );
 m_item_widget.SetPos( new_x, new_y );
 }
 }
 //--------------------------------------------------------------------------
 static void UpdateItemInfo(Widget root_widget, EntityAI item)
 {
 if (!root_widget || !item) return;
 
 Widget panelInfo = root_widget.FindAnyWidget("InventoryInfoPanelWidget");
 if ( panelInfo )
 {
 if ( item.IsInherited( ZombieBase ) || item.IsInherited( Car ) )
 {
 panelInfo.Show( false );
 }
 else
 {
 panelInfo.Show( true );
 }
 }
 
 if ( !item.IsInherited( ZombieBase ) && !item.IsInherited( Car ) )
 {
 InventoryItem iItem = InventoryItem.Cast( item );
 WidgetTrySetText(root_widget, "ItemDescWidget", iItem.GetTooltip());
 }
 
 WidgetTrySetText(root_widget, "ItemNameWidget", item.GetDisplayName());
 InspectMenuNew.UpdateItemInfoDamage(root_widget, item);
 InspectMenuNew.UpdateItemInfoLiquidType(root_widget, item);
 InspectMenuNew.UpdateItemInfoTemperature(root_widget, item);
 InspectMenuNew.UpdateItemInfoWetness(root_widget, item);
 InspectMenuNew.UpdateItemInfoQuantity(root_widget, item);
 InspectMenuNew.UpdateItemInfoWeight(root_widget, item);
 InspectMenuNew.UpdateItemInfoFoodStage(root_widget, item);
 InspectMenuNew.UpdateItemInfoCleanness(root_widget, item);
 
 Widget content = root_widget.FindAnyWidget("InventoryInfoPanelWidget");
 }
 
 //--------------------------------------------------------------------------
 static void UpdateSlotInfo(Widget root_widget, string name, string desc = "")
 {
 if (!root_widget ) return;
 
 WidgetTrySetText(root_widget, "ItemNameWidget", name);
 }
 
 //--------------------------------------------------------------------------
 static void UpdateItemInfoDamage(Widget root_widget, EntityAI item)
 {
 if ( item.IsInherited( ZombieBase ) || item.IsInherited( Car ) ) return;
 
 int damageLevel = item.GetHealthLevel();
 
 switch(damageLevel)
 {
 case GameConstants.STATE_RUINED:
 {
 WidgetTrySetText(root_widget, "ItemDamageWidget", "#inv_inspect_ruined", Colors.COLOR_RUINED);
 break;
 }
 case GameConstants.STATE_BADLY_DAMAGED:
 {
 WidgetTrySetText(root_widget, "ItemDamageWidget", "#inv_inspect_badly", Colors.COLOR_BADLY_DAMAGED);
 break;
 }
 
 case GameConstants.STATE_DAMAGED:
 {
 WidgetTrySetText(root_widget, "ItemDamageWidget", "#inv_inspect_damaged", Colors.COLOR_DAMAGED);
 break;
 }
 
 case GameConstants.STATE_WORN:
 {
 WidgetTrySetText(root_widget, "ItemDamageWidget", "#inv_inspect_worn", Colors.COLOR_WORN);
 break;
 }
 
 case GameConstants.STATE_PRISTINE:
 {
 WidgetTrySetText(root_widget, "ItemDamageWidget", "#inv_inspect_pristine", Colors.COLOR_PRISTINE);
 break;
 }
 
 default:
 {
 WidgetTrySetText(root_widget, "ItemDamageWidget", "ERROR", Colors.COLOR_PRISTINE);
 break;
 }
 }
 
 }
 
 //--------------------------------------------------------------------------
 static void UpdateItemInfoLiquidType(Widget root_widget, EntityAI item)
 {
 if ( item.IsInherited( ZombieBase ) || item.IsInherited( Car ) ) return;
 
 ItemBase item_base = ItemBase.Cast( item );
 
 if( item_base && item_base.GetQuantity() > 0 && item_base.IsBloodContainer() )
 {
 BloodContainerBase blood_container = BloodContainerBase.Cast( item_base );
 
 if( blood_container.GetBloodTypeVisible() )
 {
 string type;
 bool positive;
 string blood_type_name = BloodTypes.GetBloodTypeName(blood_container.GetLiquidType(), type, positive);
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "#inv_inspect_blood: " + blood_type_name, Colors.COLOR_LIQUID);
 }
 else
 {
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "#inv_inspect_blood", Colors.COLOR_LIQUID);
 }
 }
 else if( item_base && item_base.GetQuantity() > 0 && item_base.IsLiquidContainer() )
 {
 int liquid_type = item_base.GetLiquidType();
 
 switch(liquid_type)
 {
 case LIQUID_WATER:
 {
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "#inv_inspect_water", Colors.COLOR_LIQUID);
 break;
 }
 
 case LIQUID_RIVERWATER:
 {
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "#inv_inspect_river_water", Colors.COLOR_LIQUID);
 break;
 }
 
 case LIQUID_VODKA:
 {
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "#inv_inspect_vodka", Colors.COLOR_LIQUID);
 break;
 }
 
 case LIQUID_BEER:
 {
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "#inv_inspect_beer", Colors.COLOR_LIQUID);
 break;
 }
 
 case LIQUID_GASOLINE:
 {
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "#inv_inspect_gasoline", Colors.COLOR_LIQUID);
 break;
 }
 
 case LIQUID_DIESEL:
 {
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "#inv_inspect_diesel", Colors.COLOR_LIQUID);
 break;
 }
 
 case LIQUID_DISINFECTANT:
 {
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "#inv_inspect_disinfectant", Colors.COLOR_LIQUID);
 break;
 }
 
 case LIQUID_SALINE:
 {
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "#inv_inspect_saline", Colors.COLOR_LIQUID);
 break;
 }
 
 default:
 {
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "ERROR", Colors.COLOR_LIQUID);
 break;
 }
 }
 }
 else
 {
 WidgetTrySetText(root_widget, "ItemLiquidTypeWidget", "");
 }
 }
 
 //--------------------------------------------------------------------------
 static void UpdateItemInfoTemperature(Widget root_widget, EntityAI item)
 {
 if ( item.IsInherited( ZombieBase ) || item.IsInherited( Car ) ) return;
 float temperature;
 ItemBase item_base = ItemBase.Cast( item );
 if( item_base )
 {
 temperature = item_base.GetTemperature();
 }
 
 if( temperature > 30 )
 {
 if ( temperature > 100 )
 {
 temperature = 100 * Math.Floor( temperature / 100.0 );
 }
 else
 {
 temperature = 10 * Math.Floor( temperature / 10.0 );
 }
 WidgetTrySetText(root_widget, "ItemTemperatureWidget", "#inv_inspect_about " + temperature.ToString() + " " + "#inv_inspect_celsius", GetTemperatureColor( temperature ) );
 } 
 else
 {
 WidgetTrySetText(root_widget, "ItemTemperatureWidget", "");
 }
 }
 
 //--------------------------------------------------------------------------
 static void UpdateItemInfoWetness(Widget root_widget, EntityAI item)
 {
 if ( item.IsInherited( ZombieBase ) || item.IsInherited( Car ) ) return;
 float wetness = 0;
 
 if ( item.IsInherited(ItemBase) )
 {
 ItemBase item_IB = ItemBase.Cast( item );
 wetness = item_IB.GetWet();
 }
 
 if( wetness < GameConstants.STATE_DAMP )
 {
 WidgetTrySetText(root_widget, "ItemWetnessWidget", "");
 }
 else if( wetness >= GameConstants.STATE_DAMP && wetness < GameConstants.STATE_WET )
 {
 WidgetTrySetText(root_widget, "ItemWetnessWidget", "#inv_inspcet_damp", Colors.COLOR_DAMP);
 }
 else if( wetness >= GameConstants.STATE_WET && wetness < GameConstants.STATE_SOAKING_WET )
 {
 WidgetTrySetText( root_widget, "ItemWetnessWidget", "#inv_inspect_wet", Colors.COLOR_WET );
 }
 else if( wetness >= GameConstants.STATE_SOAKING_WET && wetness < GameConstants.STATE_DRENCHED )
 {
 WidgetTrySetText( root_widget, "ItemWetnessWidget", "#inv_inspect_soaking_wet", Colors.COLOR_SOAKING_WET );
 }
 else
 {
 WidgetTrySetText( root_widget, "ItemWetnessWidget", "#inv_inspect_drenched", Colors.COLOR_DRENCHED );
 }
 }
 
 //--------------------------------------------------------------------------
 static void UpdateItemInfoQuantity(Widget root_widget, EntityAI item)
 {
 if ( item.IsInherited( ZombieBase ) || item.IsInherited( Car ) ) return;
 
 ItemBase item_base = ItemBase.Cast( item );
 if( item_base )
 {
 float item_quantity = item_base.GetQuantity();
 int max_quantity = item.GetQuantityMax();
 
 float quantity_ratio;
 
 if( max_quantity > 0 && !item.IsInherited( ClothingBase )) // Some items, like books, have max_quantity set to 0 => division by ZERO error in quantity_ratio
 {
 string quantity_str;
 if( item.ConfigGetString("stackedUnit") == "pc." )
 {
 if( item_quantity == 1 )
 {
 WidgetTrySetText( root_widget, "ItemQuantityWidget", item_quantity.ToString() + " " + "#inv_inspect_piece", Colors.COLOR_DEFAULT );
 }
 else
 {
 WidgetTrySetText( root_widget, "ItemQuantityWidget", item_quantity.ToString() + " " + "#inv_inspect_pieces", Colors.COLOR_DEFAULT );
 } 
 }
 else if( item.ConfigGetString("stackedUnit") == "percentage" )
 {
 quantity_ratio = Math.Round( ( item_quantity / max_quantity ) * 100 );
 
 quantity_str = "#inv_inspect_remaining " + quantity_ratio.ToString() + "#inv_inspect_percent";
 WidgetTrySetText( root_widget, "ItemQuantityWidget", quantity_str, Colors.COLOR_DEFAULT ); 
 }
 else if( item.ConfigGetString("stackedUnit") == "g" )
 {
 quantity_ratio = Math.Round( ( item_quantity / max_quantity ) * 100 );
 
 quantity_str = "#inv_inspect_remaining " + quantity_ratio.ToString() + "#inv_inspect_percent";
 WidgetTrySetText( root_widget, "ItemQuantityWidget", quantity_str, Colors.COLOR_DEFAULT ); 
 }
 else if( item.ConfigGetString("stackedUnit") == "ml" )
 {
 quantity_ratio = Math.Round( ( item_quantity / max_quantity ) * 100 );
 
 quantity_str = "#inv_inspect_remaining " + quantity_ratio.ToString() + "#inv_inspect_percent";
 WidgetTrySetText( root_widget, "ItemQuantityWidget", quantity_str, Colors.COLOR_DEFAULT );
 }
 else if( item.IsInherited( Magazine ) )
 {
 Magazine magazine_item;
 Class.CastTo(magazine_item, item);
 
 if( magazine_item.GetAmmoCount() == 1 )
 {
 WidgetTrySetText( root_widget, "ItemQuantityWidget", magazine_item.GetAmmoCount().ToString() + " " + "#inv_inspect_piece", Colors.COLOR_DEFAULT );
 }
 else
 {
 WidgetTrySetText( root_widget, "ItemQuantityWidget", magazine_item.GetAmmoCount().ToString() + " " + "#inv_inspect_pieces", Colors.COLOR_DEFAULT );
 }
 }
 else
 {
 WidgetTrySetText( root_widget, "ItemQuantityWidget", "" );
 }
 }
 else
 {
 if ( item.IsInherited( ClothingBase ) )
 {
 float heatIsolation = MiscGameplayFunctions.GetCurrentItemHeatIsolation( item_base );
 if ( heatIsolation <= GameConstants.HEATISO_THRESHOLD_BAD )
 {
 WidgetTrySetText( root_widget, "ItemQuantityWidget", "#inv_inspect_iso_bad", GetTemperatureColor( 10 ) );
 }
 else if ( ( heatIsolation > GameConstants.HEATISO_THRESHOLD_BAD ) && ( heatIsolation <= GameConstants.HEATISO_THRESHOLD_LOW ) )
 {
 WidgetTrySetText( root_widget, "ItemQuantityWidget", "#inv_inspect_iso_low", GetTemperatureColor( 20 ) );
 }
 else if ( ( heatIsolation > GameConstants.HEATISO_THRESHOLD_LOW ) && ( heatIsolation <= GameConstants.HEATISO_THRESHOLD_MEDIUM ) )
 {
 WidgetTrySetText( root_widget, "ItemQuantityWidget", "#inv_inspect_iso_medium", GetTemperatureColor( 30 ) );
 }
 else if ( ( heatIsolation > GameConstants.HEATISO_THRESHOLD_MEDIUM ) && ( heatIsolation <= GameConstants.HEATISO_THRESHOLD_HIGH ) )
 {
 WidgetTrySetText( root_widget, "ItemQuantityWidget", "#inv_inspect_iso_high", GetTemperatureColor( 50 ) );
 }
 else
 {
 WidgetTrySetText( root_widget, "ItemQuantityWidget", "#inv_inspect_iso_excel", GetTemperatureColor( 70 ) );
 }
 }
 else
 {
 WidgetTrySetText( root_widget, "ItemQuantityWidget", "" );
 }
 }
 }
 }
 
 //--------------------------------------------------------------------------
 static void UpdateItemInfoWeight(Widget root_widget, EntityAI item)
 {
 if (!item.CanDisplayWeight())
 {
 WidgetTrySetText(root_widget, "ItemWeightWidget", "", Colors.COLOR_DEFAULT);
 return;
 }
 
 ItemBase item_IB = ItemBase.Cast( item );
 if( item_IB )
 {
 int weight = item_IB.GetWeightEx();
 
 if (root_widget.GetName() != "BackPanelWidget")
 {
 weight = item_IB.GetSingleInventoryItemWeightEx();
 }
 
 if (weight >= 1000)
 {
 int kilos = Math.Round(weight / 1000.0);
 WidgetTrySetText(root_widget, "ItemWeightWidget", "#inv_inspect_about" + " " + kilos.ToString() + " " + "#inv_inspect_kg", Colors.COLOR_DEFAULT);
 }
 else if (weight >= 500)
 {
 WidgetTrySetText(root_widget, "ItemWeightWidget", "#inv_inspect_under_1", Colors.COLOR_DEFAULT);
 } 
 else if (weight >= 250)
 {
 WidgetTrySetText(root_widget, "ItemWeightWidget", "#inv_inspect_under_05", Colors.COLOR_DEFAULT);
 }
 else 
 {
 WidgetTrySetText(root_widget, "ItemWeightWidget", "#inv_inspect_under_025", Colors.COLOR_DEFAULT);
 }
 }
 }
 
 //--------------------------------------------------------------------------
 static void UpdateItemInfoFoodStage(Widget root_widget, EntityAI item)
 {
 Edible_Base food_item = Edible_Base.Cast( item );
 if ( food_item && food_item.HasFoodStage() )
 {
 ref FoodStage food_stage = food_item.GetFoodStage();
 FoodStageType food_stage_type = food_stage.GetFoodStageType();
 
 switch( food_stage_type )
 { 
 case FoodStageType.RAW:
 {
 WidgetTrySetText( root_widget, "ItemFoodStageWidget", "#inv_inspect_raw", Colors.COLOR_RAW );
 break;
 }
 case FoodStageType.BAKED:
 {
 WidgetTrySetText( root_widget, "ItemFoodStageWidget", "#inv_inspect_baked", Colors.COLOR_BAKED );
 break;
 }
 case FoodStageType.BOILED:
 {
 WidgetTrySetText( root_widget, "ItemFoodStageWidget", "#inv_inspect_boiled", Colors.COLOR_BOILED );
 break;
 }
 case FoodStageType.DRIED:
 {
 WidgetTrySetText( root_widget, "ItemFoodStageWidget", "#inv_inspect_dried", Colors.COLOR_DRIED );
 break;
 }
 case FoodStageType.BURNED:
 {
 WidgetTrySetText( root_widget, "ItemFoodStageWidget", "#inv_inspect_burned", Colors.COLOR_BURNED );
 break;
 }
 case FoodStageType.ROTTEN:
 {
 WidgetTrySetText( root_widget, "ItemFoodStageWidget", "#inv_inspect_rotten", Colors.COLOR_ROTTEN );
 break;
 }
 }
 }
 else
 {
 WidgetTrySetText( root_widget, "ItemFoodStageWidget", "" );
 }
 }
 
 
 //--------------------------------------------------------------------------
 static void UpdateItemInfoCleanness(Widget root_widget, EntityAI item)
 {
 ItemBase ib = ItemBase.Cast(item);
 if(ib && ib.m_Cleanness==1)
 {
 WidgetTrySetText( root_widget, "ItemCleannessWidget", "#inv_inspect_cleaned", Colors.WHITEGRAY );
 }
 else
 {
 WidgetTrySetText( root_widget, "ItemCleannessWidget", "" );
 }
 }
 
 
 
 //--------------------------------------------------------------------------
 static void WidgetTrySetText(Widget root_widget, string widget_name, string text, int color = 0)
 {
 TextWidget widget = TextWidget.Cast( root_widget.FindAnyWidget(widget_name) );
 RichTextWidget rt_widget = RichTextWidget.Cast( root_widget.FindAnyWidget(widget_name) );
 if (widget)
 {
 widget.SetText(text);
 Widget widget_background = root_widget.FindAnyWidget(widget_name+"Background");
 if (widget_background)
 {
 if (color != 0)
 {
 widget_background.Show( true );
 widget_background.SetColor(color | 0x7F000000);
 }
 else
 {
 widget_background.Show( false );
 }
 }
 }
 if( rt_widget )
 {
 rt_widget.Update();
 }
 }
 
};