CloudSyncStatusField.cpp

Go to the documentation of this file.

/*  SPDX-License-Identifier: GPL-2.0-or-later */
/*!********************************************************************
 
  Audacity: A Digital Audio Editor
 
  CloudSyncStatusField.cpp
 
  Dmitry Vedenko
 
**********************************************************************/
 
#include "CloudSyncStatusField.h"
 
#include <algorithm>
 
#include <wx/bitmap.h>
#include <wx/dcbuffer.h>
#include <wx/graphics.h>
#include <wx/statusbr.h>
 
#include "Project.h"
#include "ProjectStatus.h"
#include "ProjectWindow.h"
#include "sync/ProjectCloudExtension.h"
 
#include "AllThemeResources.h"
#include "Theme.h"
#include "wxPanelWrapper.h"
 
#include "Prefs.h"
 
#if wxUSE_ACCESSIBILITY
#   include "WindowAccessible.h"
#endif
 
namespace audacity::cloud::audiocom::sync
{
namespace
{
const StatusBarField FieldId { L"CloudSyncStatus" };
 
const AttachedProjectObjects::RegisteredFactory key {
   [](AudacityProject& project)
   { return std::make_shared<CloudSyncStatusField>(project); }
};
 
class CloudSyncStatusBarFieldItem final : public StatusBarFieldItem
{
public:
   CloudSyncStatusBarFieldItem()
       : StatusBarFieldItem { FieldId }
   {
   }
 
   int GetDefaultWidth(const AudacityProject& project) const override
   {
      return CloudSyncStatusField::Get(project).GetWidth();
   }
 
   void OnSize(AudacityProject& project) override
   {
      const auto index =
         ProjectStatusFieldsRegistry::GetFieldIndex(project, name);
 
      if (index < 0)
         return;
 
      wxRect rect;
      if (ProjectWindow::Get(project).GetStatusBar()->GetFieldRect(index, rect))
         CloudSyncStatusField::Get(project).OnSize(rect);
   }
 
   void
   SetText(AudacityProject& project, const TranslatableString& msg) override
   {
   }
 
   TranslatableString GetText(const AudacityProject& project) const override
   {
      return CloudSyncStatusField::Get(project).GetText();
   }
 
   bool IsVisible(const AudacityProject& project) const override
   {
      return CloudSyncStatusField::Get(project).IsVisible();
   }
 
   void MarkDirty(const AudacityProject& project)
   {
      DispatchFieldChanged(project);
   }
}; // class CloudSyncStatusBarFieldItem
 
StatusBarFieldItemRegistrator rateStatusBarField {
   std::make_unique<CloudSyncStatusBarFieldItem>(),
   { {}, { Registry::OrderingHint::After, RateStatusBarField().GET() } }
};
 
const auto CloudSyncFailedMessage   = XO("Failed.");
const auto CloudSyncProgressMessage = XO("Syncing to audio.com... (%d%%)");
const auto Padding                  = 2;
const auto ProgressBarWidth         = 240;
const auto ProgressBarHeight        = 10;
const auto ProgressBarBorderSize    = 1;
 
#if __WXMAC__
const auto StatusFieldPadding = 20;
#else
const auto StatusFieldPadding = 0;
#endif
 
} // namespace
 
class CloudSyncStatusField::StatusWidget final :
    public wxPanelWrapper,
    public PrefsListener
{
public:
   StatusWidget(CloudSyncStatusField& owner, wxWindow* parent)
       : wxPanelWrapper { parent }
       , mOwner { owner }
   {
      SetBackgroundStyle(wxBG_STYLE_PAINT);
      UpdatePrefs();
 
      Bind(wxEVT_PAINT, [this](auto&) { OnPaint(); });
 
#if wxUSE_ACCESSIBILITY
      SetAccessible(safenew WindowAccessible(this));
#endif
   }
 
   ~StatusWidget() override
   {
   }
 
   void SetRect(const wxRect& rect)
   {
      SetSize(rect);
   }
 
   int GetPreferredWidth(State state) const
   {
      switch (state)
      {
      case State::Failed:
         return mSyncedBitmap->GetWidth() + mCloudSyncFailedMessageWidth +
                Padding * 4;
      case State::Uploading:
         return mProgressBitmap->GetWidth() + mCloudSyncProgressMessageWidth +
                ProgressBarWidth + Padding * 4;
      }
 
      return mSyncedBitmap->GetWidth() + Padding * 2;
   }
 
   const wxBitmap* GetBitmap() const
   {
      return mOwner.mState == State::Uploading ? mProgressBitmap :
                                                 mSyncedBitmap;
   }
 
   TranslatableString GetTranslatableText() const
   {
      if (mOwner.mState == State::Uploading)
         return TranslatableString { CloudSyncProgressMessage }.Format(
            mOwner.mProgress);
      else if (mOwner.mState == State::Failed)
         return CloudSyncFailedMessage;
 
      return {};
   }
 
   wxString GetText() const
   {
      return GetTranslatableText().Translation();
   }
 
   void OnPaint()
   {
      wxAutoBufferedPaintDC dc(this);
      std::unique_ptr<wxGraphicsContext> gc(wxGraphicsContext::Create(dc));
 
      auto bitmap = GetBitmap();
 
      const wxSize widgetSize = GetSize();
      const wxSize bitmapSize = bitmap->GetSize();
 
      gc->SetBrush(wxBrush(GetBackgroundColour()));
      gc->DrawRectangle(0, 0, widgetSize.x, widgetSize.y);
      gc->DrawBitmap(
         *bitmap, Padding, (widgetSize.y - bitmapSize.y) / 2.0, bitmapSize.x,
         bitmapSize.y);
 
      const auto text = GetText();
 
      if (text.empty())
         return;
 
      gc->SetFont(GetFont(), GetForegroundColour());
      gc->DrawText(text, Padding + bitmapSize.x + 2 * Padding, 0);
 
      if (mOwner.mState != State::Uploading)
         return;
 
      gc->SetAntialiasMode(wxANTIALIAS_NONE);
 
      const auto progress = std::clamp(mOwner.mProgress, 0, 100);
 
      const auto progressFilledPen =
         gc->CreatePen(wxGraphicsPenInfo {}
                          .Colour(wxColour(0xc3c3c3))
                          .Width(ProgressBarBorderSize));
 
      const auto progressEmptyPen =
         gc->CreatePen(wxGraphicsPenInfo {}
                          .Colour(wxColour(0xc3c3c3))
                          .Width(ProgressBarBorderSize));
      const auto zeroPen = gc->CreatePen(
         wxGraphicsPenInfo {}.Width(0).Style(wxPENSTYLE_TRANSPARENT));
 
      const auto progressFilledBrush = gc->CreateBrush(wxColour(0x3cf03c));
      const auto progressEmptyBrush  = gc->CreateBrush(wxColour(0xffffff));
 
      const auto progressBarBorderLeft =
         Padding + bitmapSize.x + 2 * Padding + mCloudSyncProgressMessageWidth;
 
      const auto progressBarBorderRight =
         progressBarBorderLeft + ProgressBarWidth;
 
      const auto progressBarBorderTop =
         (widgetSize.y - ProgressBarHeight) / 2.0;
 
      const auto progressBarBorderBottom =
         progressBarBorderTop + ProgressBarHeight;
 
      const auto filledWidth =
         (ProgressBarWidth - ProgressBarBorderSize * 2) * progress / 100;
 
      const auto progressBarFillLeft =
         progressBarBorderLeft + ProgressBarBorderSize;
      const auto progressBarFillRight = progressBarFillLeft + filledWidth;
 
      const auto progressBarEmptyLeft =
         progressBarFillRight + (progress > 0 ? 1 : 0);
      const auto progressBarEmptyRight =
         progressBarBorderRight - ProgressBarBorderSize;
 
      const auto filledHeight = ProgressBarHeight - ProgressBarBorderSize;
 
      // Draw border
      if (progress == 0)
         gc->SetPen(progressEmptyPen);
      else
         gc->SetPen(progressFilledPen);
 
      gc->StrokeLine(
         progressBarBorderLeft, progressBarBorderTop, progressBarBorderLeft,
         progressBarBorderBottom);
 
      if (progress > 0)
      {
         gc->StrokeLine(
            progressBarFillLeft, progressBarBorderTop, progressBarFillRight,
            progressBarBorderTop);
 
         gc->StrokeLine(
            progressBarFillLeft, progressBarBorderBottom, progressBarFillRight,
            progressBarBorderBottom);
 
         gc->SetPen(zeroPen);
         gc->SetBrush(progressFilledBrush);
 
         gc->DrawRectangle(
            progressBarFillLeft, progressBarBorderTop + ProgressBarBorderSize,
            progressBarFillRight - progressBarFillLeft + 1, filledHeight);
      }
 
      if (progress < 100)
      {
         gc->SetPen(progressEmptyPen);
 
         gc->StrokeLine(
            progressBarEmptyLeft, progressBarBorderTop, progressBarEmptyRight,
            progressBarBorderTop);
 
         gc->StrokeLine(
            progressBarEmptyLeft, progressBarBorderBottom,
            progressBarEmptyRight, progressBarBorderBottom);
 
         gc->SetPen(zeroPen);
         gc->SetBrush(progressEmptyBrush);
 
         gc->DrawRectangle(
            progressBarEmptyLeft, progressBarBorderTop + ProgressBarBorderSize,
            progressBarEmptyRight - progressBarEmptyLeft + 1, filledHeight);
      }
 
      if (progress == 100)
         gc->SetPen(progressFilledPen);
      else
         gc->SetPen(progressEmptyPen);
 
      gc->StrokeLine(
         progressBarBorderRight, progressBarBorderTop, progressBarBorderRight,
         progressBarBorderBottom);
   }
 
   void UpdatePrefs() override
   {
      mSyncedBitmap   = &theTheme.Bitmap(bmpCloud);
      mProgressBitmap = &theTheme.Bitmap(bmpCloudProgress);
 
      mCloudSyncFailedMessageWidth =
         GetTextExtent(CloudSyncFailedMessage.Translation()).x;
 
      mCloudSyncProgressMessageWidth =
         GetTextExtent(TranslatableString { CloudSyncProgressMessage }
                          .Format(100)
                          .Translation())
            .x;
   }
 
   void UpdateName()
   {
      SetName(GetTranslatableText());
   }
 
private:
   CloudSyncStatusField& mOwner;
 
   const wxBitmap* mSyncedBitmap {};
   const wxBitmap* mProgressBitmap {};
 
   int mCloudSyncFailedMessageWidth {};
   int mCloudSyncProgressMessageWidth {};
}; // class CloudSyncStatusField::StatusWidget
 
CloudSyncStatusField::CloudSyncStatusField(AudacityProject& project)
    : mProject { project }
    , mCloudExtension { ProjectCloudExtension::Get(project) }
    , mCloudStatusChangedSubscription { mCloudExtension.SubscribeStatusChanged(
         [this](const auto& extension) { OnCloudStatusChanged(extension); },
         true) }
{
}
 
CloudSyncStatusField::~CloudSyncStatusField() = default;
 
CloudSyncStatusField& CloudSyncStatusField::Get(AudacityProject& project)
{
   return project.AttachedObjects::Get<CloudSyncStatusField&>(key);
}
 
const CloudSyncStatusField&
CloudSyncStatusField::Get(const AudacityProject& project)
{
   return Get(const_cast<AudacityProject&>(project));
}
 
int CloudSyncStatusField::GetWidth() const
{
   return mCloudExtension.IsCloudProject() ?
             (GetStatusWidget().GetPreferredWidth(mState) +
              StatusFieldPadding) :
             0;
}
 
void CloudSyncStatusField::OnSize(const wxRect& rect)
{
   GetStatusWidget().SetRect(rect);
}
 
bool CloudSyncStatusField::IsVisible() const
{
   return mState != State::Hidden;
}
 
TranslatableString CloudSyncStatusField::GetText() const
{
   return {};
}
 
void CloudSyncStatusField::MarkDirty()
{
   auto field = dynamic_cast<CloudSyncStatusBarFieldItem*>(
      ProjectStatusFieldsRegistry::Get(FieldId));
 
   if (field)
      field->MarkDirty(mProject);
 
   auto& statusWidget = GetStatusWidget();
 
   statusWidget.Show(mState != State::Hidden);
   statusWidget.UpdateName();
 
   if (statusWidget.GetParent())
      statusWidget.GetParent()->Refresh();
   else
      statusWidget.Refresh();
}
 
void CloudSyncStatusField::OnCloudStatusChanged(
   const CloudStatusChangedMessage& message)
{
   mState = [](ProjectSyncStatus status)
   {
      switch (status)
      {
      case ProjectSyncStatus::Local:
         return State::Hidden;
      case ProjectSyncStatus::Unsynced:
         return State::Dirty;
      case ProjectSyncStatus::Synced:
         return State::Synced;
      case ProjectSyncStatus::Failed:
         return State::Failed;
      case ProjectSyncStatus::Syncing:
         return State::Uploading;
      default:
         return State::Hidden;
      }
   }(message.Status);
 
   if (mState == State::Uploading)
      mProgress = static_cast<int>(message.Progress * 100.0);
 
   MarkDirty();
}
 
CloudSyncStatusField::StatusWidget& CloudSyncStatusField::GetStatusWidget()
{
   if (!mStatusWidget)
   {
      mStatusWidget = safenew StatusWidget(
         *this, ProjectWindow::Get(mProject).GetStatusBar());
 
      mStatusWidget->Show(mCloudExtension.IsCloudProject());
   }
 
   return *mStatusWidget;
}
 
const CloudSyncStatusField::StatusWidget&
CloudSyncStatusField::GetStatusWidget() const
{
   return const_cast<CloudSyncStatusField*>(this)->GetStatusWidget();
}
} // namespace audacity::cloud::audiocom::sync