[ADDITIVE] Add toggle for filtering memory overlap items in memory de…

…signer.

editors/MemoryDesigner/MemoryDesignConstructor.cpp

@@ -195,6 +195,22 @@ bool MemoryDesignConstructor::unconnectedMemoryItemsAreFiltered() const
     return itemHandler_->unconnectedMemoryItemsAreFiltered();
 }
 
+//-----------------------------------------------------------------------------
+// Function: MemoryDesignConstructor::filterMemoryOverlapItems()
+//-----------------------------------------------------------------------------
+void MemoryDesignConstructor::filterMemoryOverlapItems(bool filterOverlap)
+{
+    itemHandler_->filterMemoryOverlapItems(filterOverlap);
+}
+
+//-----------------------------------------------------------------------------
+// Function: MemoryDesignConstructor::memoryOverlapItemsAreFiltered()
+//-----------------------------------------------------------------------------
+bool MemoryDesignConstructor::memoryOverlapItemsAreFiltered() const
+{
+    return itemHandler_->memoryOverlapItemsAreFiltered();
+}
+
 //-----------------------------------------------------------------------------
 // Function: MemoryDesignConstructor::constructMemoryDesignItems()
 //-----------------------------------------------------------------------------

editors/MemoryDesigner/MemoryDesignConstructor.h

@@ -154,6 +154,20 @@ class MemoryDesignConstructor : public QObject
      */
     bool unconnectedMemoryItemsAreFiltered() const;
 
+    /*!
+     *  Set a new value for filtering the memory overlap items.
+     *
+     *      @param [in] filterOverlap       Value for filtering memory overlap.
+     */
+    void filterMemoryOverlapItems(bool filterOverlap);
+
+    /*!
+     *  Check if the memory overlap items are filtered.
+     *
+     *      @return True, if the memory overlap items are filtered, false otherwise.
+     */
+    bool memoryOverlapItemsAreFiltered() const;
+
     /*!
      *  Construct memory design items from the selected connection graph.
      *

editors/MemoryDesigner/MemoryDesignDocument.cpp

@@ -360,6 +360,22 @@ void MemoryDesignDocument::filterUnconnectedMemoryItems(bool filterUnconnected)
     diagram_->filterUnconnectedMemoryItems(filterUnconnected);
 }
 
+//-----------------------------------------------------------------------------
+// Function: MemoryDesignDocument::filterMemoryOverlapItems()
+//-----------------------------------------------------------------------------
+void MemoryDesignDocument::filterMemoryOverlapItems(bool filterOverlap)
+{
+    diagram_->filterMemoryOverlapItems(filterOverlap);
+}
+
+//-----------------------------------------------------------------------------
+// Function: MemoryDesignDocument::memoryOverlapItemsAreFiltered()
+//-----------------------------------------------------------------------------
+bool MemoryDesignDocument::memoryOverlapItemsAreFiltered() const
+{
+    return diagram_->memoryOverlapItemsAreFiltered();
+}
+
 //-----------------------------------------------------------------------------
 // Function: MemoryDesignDocument::exportImage()
 //-----------------------------------------------------------------------------

editors/MemoryDesigner/MemoryDesignDocument.h

@@ -196,6 +196,20 @@ class MemoryDesignDocument : public TabDocument
      */
     void filterUnconnectedMemoryItems(bool filterUnconnected);
 
+    /*!
+     *  Filter the memory overlap items.
+     *
+     *      @param [in] filterOverlap   Value for filtering.
+     */
+    void filterMemoryOverlapItems(bool filterOverlap);
+
+    /*!
+     *  Check if the memory overlap items are filtered.
+     *
+     *      @return True, if the memory overlap items are filtered, false otherwise.
+     */
+    bool memoryOverlapItemsAreFiltered() const;
+
 public slots:
 
     /*!

editors/MemoryDesigner/MemoryDesignerDiagram.cpp

@@ -179,6 +179,22 @@ bool MemoryDesignerDiagram::unconnectedMemoryItemsAreFiltered() const
     return memoryConstructor_->unconnectedMemoryItemsAreFiltered();
 }
 
+//-----------------------------------------------------------------------------
+// Function: MemoryDesignerDiagram::filterMemoryOverlapItems()
+//-----------------------------------------------------------------------------
+void MemoryDesignerDiagram::filterMemoryOverlapItems(bool filterOverlap)
+{
+    memoryConstructor_->filterMemoryOverlapItems(filterOverlap);
+}
+
+//-----------------------------------------------------------------------------
+// Function: MemoryDesignerDiagram::memoryOverlapItemsAreFiltered()
+//-----------------------------------------------------------------------------
+bool MemoryDesignerDiagram::memoryOverlapItemsAreFiltered() const
+{
+    return memoryConstructor_->memoryOverlapItemsAreFiltered();
+}
+
 //-----------------------------------------------------------------------------
 // Function: MemoryDesignerDiagram::loadDesign()
 //-----------------------------------------------------------------------------

editors/MemoryDesigner/MemoryDesignerDiagram.h

@@ -155,6 +155,20 @@ class MemoryDesignerDiagram : public QGraphicsScene
      *      @return True, if the unconnected memory items are filtered, false otherwise.
      */
     bool unconnectedMemoryItemsAreFiltered() const;
+
+    /*!
+     *  Set a new value for filtering the memory overlap items.
+     *
+     *      @param [in] filterOverlap       Value for filtering memory overlap.
+     */
+    void filterMemoryOverlapItems(bool filterOverlap);
+
+    /*!
+     *  Check if the memory overlap items are filtered.
+     *
+     *      @return True, if the memory overlap items are filtered, false otherwise.
+     */
+    bool memoryOverlapItemsAreFiltered() const;
 
     /*!
      *  Load a design using the selected view.

editors/MemoryDesigner/MemoryGraphicsItemHandler.cpp

@@ -19,19 +19,13 @@
 #include <editors/MemoryDesigner/AddressSpaceGraphicsItem.h>
 #include <editors/MemoryDesigner/MemoryMapGraphicsItem.h>
 #include <editors/MemoryDesigner/MemoryColumn.h>
+#include <editors/MemoryDesigner/MemoryCollisionItem.h>
 
 //-----------------------------------------------------------------------------
 // Function: MemoryGraphicsItemHandler::MemoryGraphicsItemHandler()
 //-----------------------------------------------------------------------------
 MemoryGraphicsItemHandler::MemoryGraphicsItemHandler():
-QObject(),
-filterAddressSpaceSegments_(true),
-filterAddressBlocks_(true),
-filterRegisters_(true),
-filterFields_(true),
-filterUnconnectedMemoryItems_(true),
-memoryMapItems_(),
-spaceItems_()
+QObject()
 {
 
 }
@@ -115,12 +109,12 @@ void MemoryGraphicsItemHandler::filterUnconnectedMemoryItems(bool filterUnconnec
 {
     filterUnconnectedMemoryItems_ = filterUnconnected;
 
-    foreach (AddressSpaceGraphicsItem* spaceItem, spaceItems_)
+    for (AddressSpaceGraphicsItem* spaceItem : spaceItems_)
     {
         filterUnconnectedMemoryItem(spaceItem);
     }
 
-    foreach (MemoryMapGraphicsItem* mapItem, memoryMapItems_)
+    for (MemoryMapGraphicsItem* mapItem : memoryMapItems_)
     {
         filterUnconnectedMemoryItem(mapItem);
     }
@@ -145,6 +139,30 @@ bool MemoryGraphicsItemHandler::unconnectedMemoryItemsAreFiltered() const
     return filterUnconnectedMemoryItems_;
 }
 
+//-----------------------------------------------------------------------------
+// Function: MemoryGraphicsItemHandler::filterMemoryOverlapItems()
+//-----------------------------------------------------------------------------
+void MemoryGraphicsItemHandler::filterMemoryOverlapItems(bool filterOverlap)
+{
+    filterMemoryOverlapItems_ = filterOverlap;
+
+    for (auto addrSpace : spaceItems_)
+    {
+        for (auto overlapItem : addrSpace->getMemoryCollisions())
+        {
+            overlapItem->setVisible(!filterOverlap);
+        }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Function: MemoryGraphicsItemHandler::memoryOverlapItemsAreFiltered()
+//-----------------------------------------------------------------------------
+bool MemoryGraphicsItemHandler::memoryOverlapItemsAreFiltered() const
+{
+    return filterMemoryOverlapItems_;
+}
+
 //-----------------------------------------------------------------------------
 // Function: MemoryGraphicsItemHandler::createMemoryItems()
 //-----------------------------------------------------------------------------
@@ -241,7 +259,7 @@ void MemoryGraphicsItemHandler::connectGraphicsItemSignals(MainMemoryGraphicsIte
 //-----------------------------------------------------------------------------
 void MemoryGraphicsItemHandler::createFieldOverlapItems()
 {
-    foreach (MemoryMapGraphicsItem* mapItem, memoryMapItems_)
+    for (MemoryMapGraphicsItem* mapItem : memoryMapItems_)
     {
         mapItem->createFieldOverlapItems();
     }

editors/MemoryDesigner/MemoryGraphicsItemHandler.h

@@ -115,6 +115,20 @@ class MemoryGraphicsItemHandler : public QObject
      */
     bool unconnectedMemoryItemsAreFiltered() const;
 
+    /*!
+     *  Set a new value for filtering the memory overlap items.
+     *
+     *      @param [in] filterOverlap       Value for filtering memory overlap.
+     */
+    void filterMemoryOverlapItems(bool filterOverlap);
+
+    /*!
+     *  Check if the memory overlap items are filtered.
+     *
+     *      @return True, if the memory overlap items are filtered, false otherwise.
+     */
+    bool memoryOverlapItemsAreFiltered() const;
+
     /*!
      *  Create the memory items found in the design.
      *
@@ -188,19 +202,22 @@ class MemoryGraphicsItemHandler : public QObject
     //-----------------------------------------------------------------------------
 
     //! Value for filtering address space segments.
-    bool filterAddressSpaceSegments_;
+    bool filterAddressSpaceSegments_ = true;
 
     //! Value for filtering memory map address blocks.
-    bool filterAddressBlocks_;
+    bool filterAddressBlocks_ = true;
 
     //! Value for filtering address block registers.
-    bool filterRegisters_;
+    bool filterRegisters_ = true;
 
     //! Value for filtering register fields.
-    bool filterFields_;
+    bool filterFields_ = true;
 
     //! Value for filtering unconnected memory items.
-    bool filterUnconnectedMemoryItems_;
+    bool filterUnconnectedMemoryItems_ = true;
+
+    //! Value for filtering memory overlap items.
+    bool filterMemoryOverlapItems_ = false;
 
     //! List of all the created memory map graphics items.
     QVector<MemoryMapGraphicsItem*> memoryMapItems_;

kactus.qrc

@@ -156,6 +156,7 @@
         <file>common/graphics/search.png</file>
         <file>common/graphics/fail.png</file>
         <file>common/graphics/pass.png</file>
+        <file>common/graphics/filterMemoryOverlap.png</file>
     </qresource>
     <qresource prefix="/">
         <file>common/graphics/splash.png</file>

mainwindow/mainwindow.cpp

@@ -509,6 +509,13 @@ void MainWindow::setupActions()
     connect(actionFilterUnconnectedMemoryItems_, SIGNAL(triggered(bool)),
         this, SLOT(onFilterUnconnectedMemoryItems(bool)), Qt::UniqueConnection);
 
+    //! Initialize the action to filter memory overlap items.
+    actionFilterMemoryOverlap_ = new QAction(QIcon(":icons/common/graphics/filterMemoryOverlap.png"),
+        tr("Filter memory overlap markers"), this);
+    actionFilterMemoryOverlap_->setCheckable(true);
+    connect(actionFilterMemoryOverlap_, SIGNAL(triggered(bool)), 
+        this, SLOT(onFilterMemoryOverlapItems(bool)), Qt::UniqueConnection);
+
     // Initialize the action to zoom in.
     actZoomIn_ = new QAction(QIcon(":/icons/common/graphics/view-zoom_in.png"), tr("Zoom In"), this);
     actZoomIn_->setEnabled(false);
@@ -704,6 +711,7 @@ void MainWindow::setupMenus()
     filteringGroup_->addAction(actionCondenseMemoryItems_);
     filteringGroup_->addAction(actionCondenseFieldItems_);
     filteringGroup_->addAction(actionExtendFieldItems_);
+    filteringGroup_->addAction(actionFilterMemoryOverlap_);
 
     filteringAction_ = ribbon_->addGroup(filteringGroup_);
     filteringAction_->setVisible(false);
@@ -1028,6 +1036,7 @@ void MainWindow::updateMenuStrip()
         actionFilterRegisters_->setChecked(memoryDocument->addressBlockRegistersAreFiltered());
         actionFilterFields_->setChecked(memoryDocument->fieldsAreFiltered());
         actionFilterUnconnectedMemoryItems_->setChecked(memoryDocument->unconnectedMemoryItemsAreFiltered());
+        actionFilterMemoryOverlap_->setChecked(memoryDocument->memoryOverlapItemsAreFiltered());
     }
 
     filteringAction_->setVisible(isMemoryDesign);
@@ -3849,3 +3858,15 @@ void MainWindow::onFilterUnconnectedMemoryItems(bool filterUnconnected)
         memoryDocument->filterUnconnectedMemoryItems(filterUnconnected);
     }
 }
+
+//-----------------------------------------------------------------------------
+// Function: MainWindow::onFilterMemoryOverlapItems()
+//-----------------------------------------------------------------------------
+void MainWindow::onFilterMemoryOverlapItems(bool filterOverlap)
+{
+    MemoryDesignDocument* memoryDocument = dynamic_cast<MemoryDesignDocument*>(designTabs_->currentWidget());
+    if (memoryDocument && !memoryDocument->isProtected())
+    {
+        memoryDocument->filterMemoryOverlapItems(filterOverlap);
+    }
+}

mainwindow/mainwindow.h

@@ -519,6 +519,13 @@ private slots:
      */
     void onFilterUnconnectedMemoryItems(bool filterUnconnected);
 
+    /*!
+     *  Set the filtering of the memory overlap items within a memory design.
+     *
+     *      @param [in] filterOverlap   Value for the filter.
+     */
+    void onFilterMemoryOverlapItems(bool filterOverlap);
+
     /*!
      *  Open the document containing the selected component and select the identified component item editor.
      *
@@ -874,6 +881,9 @@ private slots:
     //! The action to filter unconnected memory items in a memory design.
     QAction* actionFilterUnconnectedMemoryItems_;
 
+    //! Action to toggle visibility of memory overlap items in memory designer.
+    QAction* actionFilterMemoryOverlap_ = nullptr;
+
     QMenu* generationMenu_ = nullptr;
 
 	//! The menu containing the actions to select which windows to display.

version.h

@@ -10,20 +10,20 @@
 #ifndef VERSIONNO__H
 #define VERSIONNO__H
 
-#define VERSION_FULL           3.13.218.0
+#define VERSION_FULL           3.13.228.0
 
 #define VERSION_BASEYEAR       0
-#define VERSION_DATE           "2024-12-03"
-#define VERSION_TIME           "14:02:16"
+#define VERSION_DATE           "2024-12-04"
+#define VERSION_TIME           "14:34:15"
 
 #define VERSION_MAJOR          3
 #define VERSION_MINOR          13
-#define VERSION_BUILDNO        218
+#define VERSION_BUILDNO        228
 #define VERSION_EXTEND         0
 
-#define VERSION_FILE           3,13,218,0
-#define VERSION_PRODUCT        3,13,218,0
-#define VERSION_FILESTR        "3,13,218,0"
-#define VERSION_PRODUCTSTR     "3,13,218,0"
+#define VERSION_FILE           3,13,228,0
+#define VERSION_PRODUCT        3,13,228,0
+#define VERSION_FILESTR        "3,13,228,0"
+#define VERSION_PRODUCTSTR     "3,13,228,0"
 
 #endif