EditorHelpers.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2019 Infoscitex, a DCS Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef EDITOR_HELPERS_HPP
#define EDITOR_HELPERS_HPP
 
#include <sstream>
 
#include <QString>
#include <QStringList>
#include <QTextCursor>
 
// Util Includes
#include "UtCompilerAttributes.hpp"
class UtTextDocumentRange;
 
// WKF Includes
#include "WkfEnvironment.hpp"
#include "WkfUnitsObject.hpp"
 
// WSF Includes
#include "WsfPProxyNode.hpp"
 
// Wizard Includes
#include "Editor.hpp"
#include "ViExport.hpp"
 
namespace vespa
{
 
class VaPosition;
 
}
 
namespace wizard
{
 
class Editor;
 
namespace EditorHelpers
{

QString VI_EXPORT GetInsertWithComments(const UtTextDocumentRange& aEntryRange,
                                        const QString&             aAttributeName,
                                        const QString&             aInsert);

CPP17_NODISCARD bool VI_EXPORT ReplaceTextInEditor(const UtTextDocumentRange& aEntryRange,
                                                   const QString&             aAttributeName,
                                                   const QString&             aInsert);

QTextCursor VI_EXPORT FindStartCursor(const WsfPProxyNode& aNode) noexcept;

QTextCursor VI_EXPORT FindEndCursor(const WsfPProxyNode& aNode) noexcept;

int VI_EXPORT GetIndentLevel(const QString& aLine) noexcept;

QString VI_EXPORT ConstructTextToAppendToBlock(const QTextCursor& aStartCursor,
                                               const QTextCursor& aEndCursor,
                                               const QString&     aAttributeName,
                                               const QString&     aDataValue) noexcept;

void VI_EXPORT AddNewAttributeInText(const WsfPProxyNode& aProxyNode,
                                     const QString&       aAttributeName,
                                     const QString&       aDataValue) noexcept;

bool VI_EXPORT MoveToPreviousNonWhitespaceToken(QTextCursor&          aCursor,
                                                QTextCursor::MoveMode aMoveMode,
                                                int                   aOperationCount = 1) noexcept;

bool VI_EXPORT IsWhitespaceString(const QString& aText) noexcept;

bool VI_EXPORT ReplacePositionText(QStringList&             aPositionTokens,
                                   int                      aCommandIndex,
                                   const vespa::VaPosition& aNewPosition) noexcept;

bool VI_EXPORT ReplaceMGRS_Text(QStringList& aMGRS_Tokens, int aCommandIndex, const vespa::VaPosition& aNewPosition) noexcept;

template<typename UNITARY_PROPERTY>
bool ReplaceUnitaryText(QStringList& aUnitaryTokens, int aCommandIndex, UNITARY_PROPERTY& aNewUnitary) noexcept
{
   static_assert(std::is_base_of<UtUnitaryValue<typename UNITARY_PROPERTY::UnitType>, UNITARY_PROPERTY>::value,
                 "UNITARY_PROPERTY must derive from UtUnitaryValue");
 
   // Read the unitary property's value
   int valueIndex{wizard::Editor::FindNextValidToken(aUnitaryTokens, aCommandIndex + 1)};
   if (valueIndex >= 0)
   {
      // Read the unitary property's unit
      int unitIndex{wizard::Editor::FindNextValidToken(aUnitaryTokens, valueIndex + 1)};
      if (unitIndex >= 0)
      {
         // Edit the unitary property
         QString     unitaryValueStr;
         std::string unitaryUnitStr{aUnitaryTokens[unitIndex].toStdString()};
         if (UtUnitAngle::IsUnitValid(unitaryUnitStr))
         {
            // Convert the unitary property to the preferred unit
            if (aNewUnitary.ConvertToUnit(unitaryUnitStr))
            {
               // Convert the unitary property to a string
               std::ostringstream oss;
               oss << aNewUnitary;
               unitaryValueStr = QString::fromStdString(oss.str());
               // Split the unitary property and unit
               QStringList unitaryValueStrSplit{unitaryValueStr.split(' ')};
               if (unitaryValueStrSplit.size() == 2)
               {
                  // Store the unitary property value
                  unitaryValueStr = unitaryValueStrSplit[0];
               }
            }
         }
 
         // Replace the old unitary property with the new unitary property
         aUnitaryTokens[valueIndex] = unitaryValueStr;
         // The replacement succeeded
         return true;
      }
   }
   // The replacement failed
   return false;
}

void VI_EXPORT InsertTextAndResetCursor(wizard::Editor* aEditorPtr, QTextCursor& aCursor, const QString& aTextToInsert) noexcept;

QString VI_EXPORT GetPositionString(const vespa::VaPosition& aPosition) noexcept;

template<wkf::ValueType UNITARY_TYPE, typename UNITARY_PROPERTY>
QString GetUnitaryString(UNITARY_PROPERTY& aUnitary) noexcept
{
   static_assert(std::is_base_of<UtUnitaryValue<typename UNITARY_PROPERTY::UnitType>, UNITARY_PROPERTY>::value,
                 "UNITARY_PROPERTY must derive from UtUnitaryValue");
 
   // Get the unitary property's unit preference
   int unitaryUnit{wkfEnv.GetPreferenceObject<wkf::UnitsObject>()->GetUnit(UNITARY_TYPE)};
   // Convert the unitary property to the preferred unit
   aUnitary.ConvertToUnit(unitaryUnit);
   // Convert the unitary property to a string
   std::ostringstream oss;
   oss << aUnitary;
   // The unitary property string contains the value AND unit strings delimited by a single ' ' character
   return QString::fromStdString(oss.str());
}
 
} // namespace EditorHelpers
} // namespace wizard
 
#endif // EDITOR_HELPERS_HPP