Add +/- shortcuts on the memory viewer

src/ui/viewmodels/MemoryViewerViewModel.cpp

@@ -658,6 +658,45 @@ void MemoryViewerViewModel::RetreatCursorPage()
     }
 }
 
+bool MemoryViewerViewModel::IncreaseCurrentValue(uint32_t nModifier)
+{
+    if (m_bReadOnly)
+        return false;
+
+    const auto nAddress = GetAddress();
+    const auto& pEmulatorContext = ra::services::ServiceLocator::Get<ra::data::context::EmulatorContext>();
+    auto nMem = pEmulatorContext.ReadMemory(GetAddress(), GetSize());
+    auto const nMaxValue = ra::data::MemSizeMax(GetSize());
+
+    if (nMem >= nMaxValue)
+        return false;
+    if ((nMaxValue - nMem) < nModifier)
+        nModifier = (nMaxValue - nMem);
+    nMem += nModifier;
+
+    pEmulatorContext.WriteMemory(nAddress, GetSize(), nMem);
+    return true;
+}
+
+bool MemoryViewerViewModel::DecreaseCurrentValue(uint32_t nModifier)
+{
+    if (m_bReadOnly)
+        return false;
+
+    auto const nAddress = GetAddress();
+    const auto& pEmulatorContext = ra::services::ServiceLocator::Get<ra::data::context::EmulatorContext>();
+    auto nMem = pEmulatorContext.ReadMemory(GetAddress(), GetSize());
+
+    if (nMem == 0)
+        return false;
+    if (nMem < nModifier)
+        nModifier = nMem;
+    nMem -= nModifier;
+
+    pEmulatorContext.WriteMemory(nAddress, GetSize(), nMem);
+    return true;
+}
+
 void MemoryViewerViewModel::OnActiveGameChanged()
 {
     m_nNeedsRedraw |= REDRAW_ADDRESSES;

src/ui/viewmodels/MemoryViewerViewModel.hh

@@ -175,6 +175,9 @@ public:
     void AdvanceCursorPage();
     void RetreatCursorPage();
 
+    bool IncreaseCurrentValue(uint32_t nModifier);
+    bool DecreaseCurrentValue(uint32_t nModifier);
+
 protected:
     void OnValueChanged(const IntModelProperty::ChangeArgs& args) override;
 

src/ui/win32/bindings/MemoryViewerControlBinding.cpp

@@ -139,6 +139,8 @@ bool MemoryViewerControlBinding::OnKeyDown(UINT nChar)
 
     if (!m_pViewModel.IsAddressFixed())
         bHandled = HandleNavigation(nChar);
+    if (!bHandled)
+        bHandled = HandleShortcut(nChar);
 
     m_bSuppressMemoryViewerInvalidate = false;
 
@@ -236,6 +238,36 @@ bool MemoryViewerControlBinding::HandleNavigation(UINT nChar)
     }
 }
 
+bool MemoryViewerControlBinding::HandleShortcut(UINT nChar)
+{
+    const bool bShiftHeld = (GetKeyState(VK_SHIFT) < 0);
+    const bool bControlHeld = (GetKeyState(VK_CONTROL) < 0);
+
+    switch (nChar)
+    {
+        // Increment/Decrement value Shortcuts
+        case VK_ADD:
+        case VK_SUBTRACT:
+        {
+            auto nModifier = 1;
+
+            // Increase/decrease by 1 or 2 on the high and lower nibble depending key pressed
+            if (bControlHeld)
+                nModifier *= 2;
+            if (bShiftHeld)
+                nModifier *= 16;
+
+            if (nChar == VK_ADD)
+                return m_pViewModel.IncreaseCurrentValue(nModifier);
+            else
+                return m_pViewModel.DecreaseCurrentValue(nModifier);
+        }
+
+        default:
+            return false;
+    }
+}
+
 bool MemoryViewerControlBinding::OnEditInput(UINT c)
 {
     // multiple properties may change while typing, we'll do a single Invalidate after we're done

src/ui/win32/bindings/MemoryViewerControlBinding.hh

@@ -63,6 +63,7 @@ protected:
 
 private:
     bool HandleNavigation(UINT nChar);
+    bool HandleShortcut(UINT nChar);
     bool m_bSuppressMemoryViewerInvalidate = false;
 
     ra::ui::viewmodels::MemoryViewerViewModel& m_pViewModel;

tests/ui/viewmodels/MemoryViewerViewModel_Tests.cpp

@@ -1918,6 +1918,168 @@ TEST_CLASS(MemoryViewerViewModel_Tests)
         Assert::IsTrue(viewer.NeedsRedraw());
         viewer.MockRender();
     }
+
+    TEST_METHOD(TestIncreaseCurrentValueByOne)
+    {
+        MemoryViewerViewModelHarness viewer;
+        viewer.InitializeMemory(256);
+
+        // ignore if readonly
+        Assert::IsTrue(viewer.IsReadOnly());
+        Assert::IsFalse(viewer.IncreaseCurrentValue(1));
+
+        viewer.SetReadOnly(false);
+        Assert::IsFalse(viewer.IsReadOnly());
+
+        viewer.SetAddress(0x0U);
+        Assert::AreEqual({ 0U }, viewer.GetAddress());
+        Assert::AreEqual({ 0x0U }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Increase by 1 from 0x0 should result to 0X1
+        Assert::IsTrue(viewer.IncreaseCurrentValue(1));
+        Assert::AreEqual({ 0x1U }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Increase by 1 from 0xFE should result to 0XFF
+        viewer.mockEmulatorContext.WriteMemoryByte(0x0U, 0XFEU);
+        Assert::IsTrue(viewer.IncreaseCurrentValue(1));
+        Assert::AreEqual({ 0xFFU }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Increase by 1 from 0xFF should not change the value
+        Assert::IsFalse(viewer.IncreaseCurrentValue(1));
+        Assert::AreEqual({ 0xFFU }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Increase by 1 from 0x0 should result to 0X0001
+        viewer.mockEmulatorContext.WriteMemory(0x0U, MemSize::SixteenBit, 0X0U);
+        Assert::IsTrue(viewer.IncreaseCurrentValue(1));
+        Assert::AreEqual({ 0x1U }, viewer.mockEmulatorContext.ReadMemory(0U, MemSize::SixteenBit));
+
+        // Increase by 1 from 0xFFFF should not change the value
+        viewer.mockEmulatorContext.WriteMemory(0x0U, MemSize::SixteenBit, 0XFFFFU);
+        Assert::IsFalse(viewer.IncreaseCurrentValue(1));
+        Assert::AreEqual({ 0xFFFFU }, viewer.mockEmulatorContext.ReadMemory(0U, MemSize::SixteenBit));
+    }
+
+    TEST_METHOD(TestIncreaseCurrentValueBySixTeen)
+    {
+        MemoryViewerViewModelHarness viewer;
+        viewer.InitializeMemory(256);
+
+        // ignore if readonly
+        Assert::IsTrue(viewer.IsReadOnly());
+        Assert::IsFalse(viewer.IncreaseCurrentValue(16));
+
+        viewer.SetReadOnly(false);
+        Assert::IsFalse(viewer.IsReadOnly());
+
+        viewer.SetAddress(0x0U);
+        Assert::AreEqual({ 0U }, viewer.GetAddress());
+        Assert::AreEqual({ 0x0U }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Increase by 16 from 0x0 should result to 0X10
+        Assert::IsTrue(viewer.IncreaseCurrentValue(16));
+        Assert::AreEqual({ 0x10U }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Increase by 16 from 0xFE should result to 0XFF
+        viewer.mockEmulatorContext.WriteMemoryByte(0x0U, 0XFEU);
+        Assert::IsTrue(viewer.IncreaseCurrentValue(16));
+        Assert::AreEqual({ 0xFFU }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Increase by 16 from 0xFF should not change the value
+        Assert::IsFalse(viewer.IncreaseCurrentValue(16));
+        Assert::AreEqual({ 0xFFU }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Increase by 16 from 0x0 should result to 0X0010
+        viewer.mockEmulatorContext.WriteMemory(0x0U, MemSize::SixteenBit, 0X0U);
+        Assert::IsTrue(viewer.IncreaseCurrentValue(16));
+        Assert::AreEqual({ 0x10U }, viewer.mockEmulatorContext.ReadMemory(0U, MemSize::SixteenBit));
+
+        // Increase by 16 from 0xFFFF should not change the value
+        viewer.mockEmulatorContext.WriteMemory(0x0U, MemSize::SixteenBit, 0XFFFFU);
+        Assert::IsFalse(viewer.IncreaseCurrentValue(16));
+        Assert::AreEqual({ 0xFFFFU }, viewer.mockEmulatorContext.ReadMemory(0U, MemSize::SixteenBit));
+    }
+
+    TEST_METHOD(TestDecreaseCurrentValueByOne)
+    {
+        MemoryViewerViewModelHarness viewer;
+        viewer.InitializeMemory(256);
+
+        // ignore if readonly
+        Assert::IsTrue(viewer.IsReadOnly());
+        Assert::IsFalse(viewer.DecreaseCurrentValue(1));
+
+        viewer.SetReadOnly(false);
+        Assert::IsFalse(viewer.IsReadOnly());
+
+        viewer.SetAddress(0x0U);
+        Assert::AreEqual({ 0U }, viewer.GetAddress());
+        Assert::AreEqual({ 0x0U }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Decrease by 1 from 0x0 should not change the value
+        Assert::IsFalse(viewer.DecreaseCurrentValue(1));
+        Assert::AreEqual({ 0x0U }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Decrease by 1 from 0xFF should result to 0XFE
+        viewer.mockEmulatorContext.WriteMemoryByte(0x0U, 0XFFU);
+        Assert::IsTrue(viewer.DecreaseCurrentValue(1));
+        Assert::AreEqual({ 0xFEU }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Decrease by 1 from 0x1 should result to 0X0
+        viewer.mockEmulatorContext.WriteMemoryByte(0x0U, 0X1U);
+        Assert::IsTrue(viewer.DecreaseCurrentValue(1));
+        Assert::AreEqual({ 0x0U }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Decrease by 1 from 0x0 should not change the value
+        viewer.mockEmulatorContext.WriteMemory(0x0U, MemSize::SixteenBit, 0X0U);
+        Assert::IsFalse(viewer.DecreaseCurrentValue(1));
+        Assert::AreEqual({ 0x0U }, viewer.mockEmulatorContext.ReadMemory(0U, MemSize::SixteenBit));
+
+        // Decrease by 1 from 0xFFFF should result to 0XFFFE
+        viewer.mockEmulatorContext.WriteMemory(0x0U, MemSize::SixteenBit, 0XFFFFU);
+        Assert::IsTrue(viewer.DecreaseCurrentValue(1));
+        Assert::AreEqual({ 0xFFFEU }, viewer.mockEmulatorContext.ReadMemory(0U, MemSize::SixteenBit));
+    }
+
+    TEST_METHOD(TestDecreaseCurrentValueBySixteen)
+    {
+        MemoryViewerViewModelHarness viewer;
+        viewer.InitializeMemory(256);
+
+        // ignore if readonly
+        Assert::IsTrue(viewer.IsReadOnly());
+        Assert::IsFalse(viewer.DecreaseCurrentValue(16));
+
+        viewer.SetReadOnly(false);
+        Assert::IsFalse(viewer.IsReadOnly());
+
+        viewer.SetAddress(0x0U);
+        Assert::AreEqual({ 0U }, viewer.GetAddress());
+        Assert::AreEqual({ 0x0U }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Decrease by 16 from 0x0 should not change the value
+        Assert::IsFalse(viewer.DecreaseCurrentValue(16));
+        Assert::AreEqual({ 0x0U }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Decrease by 16 from 0xFF should result to 0XEF
+        viewer.mockEmulatorContext.WriteMemoryByte(0x0U, 0XFFU);
+        Assert::IsTrue(viewer.DecreaseCurrentValue(16));
+        Assert::AreEqual({ 0xEFU }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Decrease by 16 from 0x1 should result to 0X0
+        viewer.mockEmulatorContext.WriteMemoryByte(0x0U, 0X1U);
+        Assert::IsTrue(viewer.DecreaseCurrentValue(16));
+        Assert::AreEqual({ 0x0U }, viewer.mockEmulatorContext.ReadMemoryByte(0U));
+
+        // Decrease by 16 from 0x0 should not change the value
+        viewer.mockEmulatorContext.WriteMemory(0x0U, MemSize::SixteenBit, 0X0U);
+        Assert::IsFalse(viewer.DecreaseCurrentValue(16));
+        Assert::AreEqual({ 0x0U }, viewer.mockEmulatorContext.ReadMemory(0U, MemSize::SixteenBit));
+
+        // Decrease by 16 from 0xFFFF should result to 0XFFEF
+        viewer.mockEmulatorContext.WriteMemory(0x0U, MemSize::SixteenBit, 0XFFFFU);
+        Assert::IsTrue(viewer.DecreaseCurrentValue(16));
+        Assert::AreEqual({ 0xFFEFU }, viewer.mockEmulatorContext.ReadMemory(0U, MemSize::SixteenBit));
+    }
 };
 
 } // namespace tests