duckstation

duckstation, but archived from the revision just before upstream changed it to a proprietary software project, this version is the libre one
git clone https://git.neptards.moe/u3shit/duckstation.git
Log | Files | Refs | README | LICENSE

progress_callback.cpp (3432B)

      1 // SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
      2 // SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
      3 
      4 #include "progress_callback.h"
      5 #include "assert.h"
      6 #include "log.h"
      7 
      8 #include <cmath>
      9 #include <cstdio>
     10 #include <limits>
     11 
     12 Log_SetChannel(ProgressCallback);
     13 
     14 static ProgressCallback s_nullProgressCallbacks;
     15 ProgressCallback* ProgressCallback::NullProgressCallback = &s_nullProgressCallbacks;
     16 
     17 ProgressCallback::~ProgressCallback()
     18 {
     19   std::unique_ptr<State> pNextState = std::move(m_saved_state);
     20   while (pNextState)
     21     pNextState = std::move(pNextState->next_saved_state);
     22 }
     23 
     24 void ProgressCallback::PushState()
     25 {
     26   std::unique_ptr<State> pNewState = std::make_unique<State>();
     27   pNewState->cancellable = m_cancellable;
     28   pNewState->status_text = m_status_text;
     29   pNewState->progress_range = m_progress_range;
     30   pNewState->progress_value = m_progress_value;
     31   pNewState->base_progress_value = m_base_progress_value;
     32   pNewState->next_saved_state = std::move(m_saved_state);
     33   m_saved_state = std::move(pNewState);
     34 }
     35 
     36 void ProgressCallback::PopState()
     37 {
     38   DebugAssert(m_saved_state);
     39 
     40   // impose the current position into the previous range
     41   const u32 new_progress_value =
     42     (m_progress_range != 0) ?
     43       static_cast<u32>(((float)m_progress_value / (float)m_progress_range) * (float)m_saved_state->progress_range) :
     44       m_saved_state->progress_value;
     45 
     46   m_cancellable = m_saved_state->cancellable;
     47   m_status_text = std::move(m_saved_state->status_text);
     48   m_progress_range = m_saved_state->progress_range;
     49   m_progress_value = new_progress_value;
     50 
     51   m_base_progress_value = m_saved_state->base_progress_value;
     52   m_saved_state = std::move(m_saved_state->next_saved_state);
     53 }
     54 
     55 bool ProgressCallback::IsCancellable() const
     56 {
     57   return m_cancellable;
     58 }
     59 
     60 bool ProgressCallback::IsCancelled() const
     61 {
     62   return m_cancelled;
     63 }
     64 
     65 void ProgressCallback::SetTitle(const std::string_view title)
     66 {
     67 }
     68 
     69 void ProgressCallback::SetStatusText(const std::string_view text)
     70 {
     71   m_status_text.assign(text);
     72 }
     73 
     74 void ProgressCallback::SetCancellable(bool cancellable)
     75 {
     76   m_cancellable = cancellable;
     77 }
     78 
     79 void ProgressCallback::SetProgressValue(u32 value)
     80 {
     81   m_progress_value = m_base_progress_value + value;
     82 }
     83 
     84 void ProgressCallback::SetProgressRange(u32 range)
     85 {
     86   if (m_saved_state)
     87   {
     88     // impose the previous range on this range
     89     m_progress_range = m_saved_state->progress_range * range;
     90     m_base_progress_value = m_progress_value = m_saved_state->progress_value * range;
     91   }
     92   else
     93   {
     94     m_progress_range = range;
     95     m_progress_value = 0;
     96     m_base_progress_value = 0;
     97   }
     98 }
     99 
    100 void ProgressCallback::IncrementProgressValue()
    101 {
    102   SetProgressValue((m_progress_value - m_base_progress_value) + 1);
    103 }
    104 
    105 void ProgressCallback::DisplayError(const std::string_view message)
    106 {
    107   ERROR_LOG(message);
    108 }
    109 
    110 void ProgressCallback::DisplayWarning(const std::string_view message)
    111 {
    112   WARNING_LOG(message);
    113 }
    114 
    115 void ProgressCallback::DisplayInformation(const std::string_view message)
    116 {
    117   INFO_LOG(message);
    118 }
    119 
    120 void ProgressCallback::DisplayDebugMessage(const std::string_view message)
    121 {
    122   DEV_LOG(message);
    123 }
    124 
    125 void ProgressCallback::ModalError(const std::string_view message)
    126 {
    127   ERROR_LOG(message);
    128 }
    129 
    130 bool ProgressCallback::ModalConfirmation(const std::string_view message)
    131 {
    132   INFO_LOG(message);
    133   return false;
    134 }
    135 
    136 void ProgressCallback::ModalInformation(const std::string_view message)
    137 {
    138   INFO_LOG(message);
    139 }