SCR_DownloadManager_AddonDownloadLine.c

Go to the documentation of this file.

 
class SCR_DownloadManager_AddonDownloadLine : ScriptedWidgetComponent
{
    // Icon setting
    protected const string ICONICON_DOWNLOAD = "download";
    protected const string ICON_UP = "up";
    protected const string ICON_DOWN = "down";
 
    protected const Color ICON_COLORICON_DOWNLOAD = UIColors.CONTRAST_COLOR;
    protected const Color ICON_COLOR_UP = UIColors.CONFIRM;
    protected const Color ICON_COLOR_DOWN = UIColors.WARNING;
 
    protected const Color TEXT_SIZE_COLOR_DOWNLOAD = UIColors.CONTRAST_COLOR;
    protected const Color TEXT_SIZE_COLOR_DOWNLOADED = Color.White;
    protected const Color TEXT_SIZE_COLOR_ERROR = UIColors.WARNING;
 
    protected const string ICON_SIZE_DOWNLOAD = "download";
    protected const string ICON_SIZE_UPDATE = "update";
    protected const string ICON_SIZE_DOWNLOADED = "check";
 
    protected ref SCR_DownloadManager_AddonDownloadLineBaseWidgets m_Widgets = new SCR_DownloadManager_AddonDownloadLineBaseWidgets();
    protected ref SCR_WorkshopItemActionDownload m_Action;
    protected ref SCR_WorkshopItem m_Item;
 
    [Attribute("{3262679C50EF4F01}UI/Textures/Icons/icons_wrapperUI.imageset", UIWidgets.ResourcePickerThumbnail, "Imageset resource for icons", "imageset")]
    protected ResourceName m_IconImageSet;
 
    bool m_bHideButtons;
    protected bool m_bVersionChange = false;
 
    protected Widget m_wRoot;
 
    //------------------------------------------------------------------------------------------------
    override void HandlerAttached(Widget w)
    {
        m_wRoot = w;
 
        m_Widgets.Init(w);
 
        m_Widgets.m_PauseResumeButtonComponent.m_OnClicked.Insert(OnPauseButton);
        m_Widgets.m_CancelButtonComponent.m_OnClicked.Insert(OnCancelButton);
    }
 
 
    //------------------------------------------------------------------------------------------------
    override void HandlerDeattached(Widget w)
    {
        GetGame().GetCallqueue().Remove(Update);
    }
 
 
    //------------------------------------------------------------------------------------------------
    void InitForDownloadAction(SCR_WorkshopItemActionDownload action)
    {
        m_Action = action;
        Update();
        GetGame().GetCallqueue().CallLater(Update, 20, true);
    }
 
 
    //------------------------------------------------------------------------------------------------
    void InitForCancelDownloadAction(SCR_WorkshopItemActionDownload action)
    {
        m_Action = action;
        m_bHideButtons = true;
 
        Update();
        GetGame().GetCallqueue().CallLater(Update, 20, true);
    }
    
    //------------------------------------------------------------------------------------------------
    void InitForServerDownloadAction(SCR_WorkshopItemActionDownload action)
    {
        m_Action = action;
        m_bHideButtons = true;
 
        if (m_Widgets && m_Widgets.m_AddonSizeIcon)
            m_Widgets.m_AddonSizeIcon.SetVisible(false);
        
        Update();
        GetGame().GetCallqueue().CallLater(Update, 20, true);
    }
    
    
    //------------------------------------------------------------------------------------------------
    void InitForServerBrowser(SCR_WorkshopItem item, Revision overrideTargetVersion = null, bool showVersionAndSize = true)
    {
        InitForWorkshopItem(item, overrideTargetVersion, showVersionAndSize);
 
        Revision versionFrom = item.GetCurrentLocalRevision();
        Revision versionTo = overrideTargetVersion;
        if (!versionTo)
            versionTo = item.GetLatestRevision();
 
        if (!item.GetOffline()) //Missing
        {
            m_Widgets.m_AddonSizeText.SetColor(TEXT_SIZE_COLOR_DOWNLOAD);
            m_Widgets.m_AddonSizeIcon.SetColor(ICON_COLORICON_DOWNLOAD);
            m_Widgets.m_AddonSizeIcon.LoadImageFromSet(0, m_IconImageSet, ICON_SIZE_DOWNLOAD);
        }
        else //Downloaded
        {
            if (versionFrom && !Revision.AreEqual(versionFrom, versionTo))
            {
                // Need version change
                m_Widgets.m_AddonSizeText.SetColor(TEXT_SIZE_COLOR_DOWNLOAD);
                m_Widgets.m_AddonSizeIcon.SetColor(ICON_COLORICON_DOWNLOAD);
                m_Widgets.m_AddonSizeIcon.LoadImageFromSet(0, m_IconImageSet, ICON_SIZE_UPDATE);
            }
            else
            {
                // Version match
                m_Widgets.m_AddonSizeText.SetColor(TEXT_SIZE_COLOR_DOWNLOADED);
                m_Widgets.m_AddonSizeIcon.SetColor(ICON_COLOR_UP);
                m_Widgets.m_AddonSizeIcon.LoadImageFromSet(0, m_IconImageSet, ICON_SIZE_DOWNLOADED);
                
                // Display whole size
                m_Widgets.m_AddonSizeText.SetText(SCR_ByteFormat.GetReadableSize(item.GetSizeBytes()));
            }
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void InitForWorkshopItem(SCR_WorkshopItem item, Revision versionTo = null, bool showVersionAndSize = true)
    {
        m_Item = item;
 
        string addonName = item.GetName();
        m_Widgets.m_AddonNameText.SetText(addonName);
 
        if (!item.GetRestricted())
        {
            m_Widgets.m_RightWidgetGroup.SetVisible(showVersionAndSize);
 
            if (showVersionAndSize)
            {
                Revision versionFrom = item.GetCurrentLocalRevision();
                //Revision versionTo = overrideTargetVersion;
                if (versionTo == null)
                    versionTo = item.GetLatestRevision();
 
 
                float downloadSize = item.GetTargetRevisionPatchSize();
 
                bool showVersionFrom = versionFrom && !Revision.AreEqual(versionFrom, versionTo);
                m_Widgets.m_VersionFromText.SetVisible(showVersionFrom);
                m_Widgets.m_VersionArrow.SetVisible(showVersionFrom);
                if (showVersionFrom)
                    m_Widgets.m_VersionFromText.SetText(versionFrom.GetVersion());
 
                if (versionTo)
                    m_Widgets.m_VersionToText.SetText(versionTo.GetVersion());
 
                string sizeStr = SCR_ByteFormat.GetReadableSize(downloadSize);
                m_Widgets.m_AddonSizeText.SetText(sizeStr);
 
                // Display what action will be done icon
                DisplayActionIcon(versionFrom, versionTo);
 
                // Check version change
                if (versionFrom && !Revision.AreEqual(versionFrom, versionTo))
                    m_bVersionChange = true;
            }
        }
        else
        {
            // The addon is somehow restricted
            m_Widgets.m_RightWidgetGroup.SetVisible(false);
 
            string errorText = SCR_WorkshopUiCommon.GetRestrictedAddonStateText(item);
            m_Widgets.m_ErrorText.SetVisible(true);
            m_Widgets.m_ErrorText.SetText(errorText);
        }
    }
 
    //------------------------------------------------------------------------------------------------
    void DisplayError(string msg, bool positive = false)
    {
        m_Widgets.m_ErrorText.SetText(msg);
        m_Widgets.m_ErrorText.SetColor(ICON_COLOR_DOWN);
        m_Widgets.m_ErrorText.SetVisible(true);
 
        // Green for positive
        if (positive)
            m_Widgets.m_ErrorText.SetColor(ICON_COLOR_UP);
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_WorkshopItem GetItem()
    {
        return m_Item;
    }
 
    //------------------------------------------------------------------------------------------------
    Widget GetRootWidget()
    {
        return m_wRoot;
    }
 
    //------------------------------------------------------------------------------------------------
    SCR_WorkshopItemActionDownload GetDownloadAction()
    {
        return m_Action;
    }
 
    //------------------------------------------------------------------------------------------------
    protected void Update()
    {
        UpdateAllWidgets();
    }
 
    //------------------------------------------------------------------------------------------------
    protected void UpdateAllWidgets()
    {
        if (!m_Action)
            return;
 
        // Name
        m_Widgets.m_AddonNameText.SetText(m_Action.GetAddonName());
 
        // Version from
        Revision versionFrom = m_Action.GetStartRevision();
        
        m_Widgets.m_VersionArrow.SetVisible(versionFrom != null);
        m_Widgets.m_VersionFromText.SetVisible(versionFrom != null);
        
        if (versionFrom)
            m_Widgets.m_VersionFromText.SetText(versionFrom.GetVersion());
 
        // Version to
        Revision versionTo = m_Action.GetTargetRevision();
        m_Widgets.m_VersionToText.SetVisible(versionTo != null);
        if (versionTo)
            m_Widgets.m_VersionToText.SetText(versionTo.GetVersion());
 
        // Progress text
        if (m_Action.IsCompleted() || m_Action.IsFailed() || m_Action.IsCanceled())
        {
            m_Widgets.m_ProgressText.SetText(string.Empty);
        }
        else
        {
            float progress = m_Action.GetProgress();
            string progressStr = string.Format("%1%%", Math.Round(progress * 100.0));
            m_Widgets.m_ProgressText.SetText(progressStr);
        }
 
        // Progress bar
        if (m_Action.IsCompleted())
            m_Widgets.m_ProgressBar.SetCurrent(1);
        else if (m_Action.IsFailed() || m_Action.IsCanceled())
            m_Widgets.m_ProgressBar.SetCurrent(0);
        else
            m_Widgets.m_ProgressBar.SetCurrent(m_Action.GetProgress());
 
        // Download size
        float downloadSize = m_Action.GetSizeBytes();
        string sizeStr = SCR_ByteFormat.GetReadableSize(downloadSize);
        m_Widgets.m_AddonSizeText.SetText(sizeStr);
 
        if (m_Action.IsCompleted())
        {
            m_Widgets.m_AddonSizeText.SetColor(TEXT_SIZE_COLOR_DOWNLOADED);
        }
        else if (m_Action.IsFailed() || m_Action.IsCanceled())
        {
            m_Widgets.m_AddonSizeText.SetColor(TEXT_SIZE_COLOR_ERROR);
        }
        else
        {
            m_Widgets.m_AddonSizeText.SetColor(TEXT_SIZE_COLOR_DOWNLOAD);
        }
 
        // Addon Size Icon
        if (m_Action.IsCompleted())
        {
            m_Widgets.m_AddonSizeIcon.SetColor(ICON_COLOR_UP);
        }
        else if (m_Action.IsFailed() || m_Action.IsCanceled())
        {
            m_Widgets.m_AddonSizeIcon.SetColor(ICON_COLOR_DOWN);
        }
        else
        {
            m_Widgets.m_AddonSizeIcon.SetColor(ICON_COLORICON_DOWNLOAD);
        }
 
        // Buttons
        if (m_bHideButtons)
        {
            m_Widgets.m_CancelButton.SetVisible(false);
            m_Widgets.m_PauseResumeButton.SetVisible(false);
        }
        else
        {
            m_Widgets.m_PauseResumeButton.SetVisible(false);
            m_Widgets.m_CancelButton.SetVisible(false);
            if (!m_Action.IsCompleted() && !m_Action.IsFailed() && !m_Action.IsCanceled())
            {
                m_Widgets.m_PauseResumeButton.SetVisible(true);
                m_Widgets.m_CancelButton.SetVisible(true);
 
                string pauseButtonMode = "running";
                if (m_Action.IsPaused() || m_Action.IsInactive())
                    pauseButtonMode = "paused";
 
                m_Widgets.m_PauseResumeButtonComponent.SetEffectsWithAnyTagEnabled({"all", pauseButtonMode});
            }
        }
 
        // Icons when the download is over
        if (m_Action.IsCompleted())
        {
            m_Widgets.m_DownloadFailedImage.SetVisible(false);
            m_Widgets.m_DownloadFinishedImage.SetVisible(true);
        }
        else if (m_Action.IsFailed() || m_Action.IsCanceled())
        {
            m_Widgets.m_DownloadFailedImage.SetVisible(true);
            m_Widgets.m_DownloadFinishedImage.SetVisible(false);
        }
        else
        {
            m_Widgets.m_DownloadFailedImage.SetVisible(false);
            m_Widgets.m_DownloadFinishedImage.SetVisible(false);
        }
    }
 
 
 
    //------------------------------------------------------------------------------------------------
    protected void OnPauseButton()
    {
        if (!m_Action)
            return;
 
        if (m_Action.IsPaused())
            m_Action.Resume();
        else if (m_Action.IsInactive())
            m_Action.Activate();
        else
            m_Action.Pause();
    }
 
 
 
    //------------------------------------------------------------------------------------------------
    protected void OnCancelButton()
    {
        if (!m_Action)
            return;
 
        m_Action.Cancel();
    }
 
    //------------------------------------------------------------------------------------------------
    protected void DisplayActionIcon(Revision vFrom, Revision vTo)
    {
        ImageWidget wIcon = m_Widgets.m_AddonActionIcon;
        if (!wIcon)
            return;
 
        // Defaul to download
        string imageName = ICONICON_DOWNLOAD;
        Color color = ICON_COLORICON_DOWNLOAD;
 
        // Is there current verion?
        if (vFrom)
        {
            int result = vFrom.CompareTo(vTo);
 
            if (result < 0)
            {
                imageName = ICON_UP;
                color = ICON_COLOR_UP;
            }
            else if (result > 0)
            {
                imageName = ICON_DOWN;
                color = ICON_COLOR_DOWN;
            }
        }
 
        // Setup action icon widget
        wIcon.LoadImageFromSet(0, m_IconImageSet, imageName);
        wIcon.SetColor(color);
    }
};