Add Blogs: Shortcut Manager + Integrating Mark API

Author: PremadeS

_data/authors.yml

@@ -17,4 +17,10 @@ cutter:
 nirmal_manoj:
     name: Nirmal Manoj
     bio: Nirmal Manoj is a CS undergraduate student at IIIT Hyderabad, India. He was a GSoC 2020 student who worked on improving the decompiler widget.
-    image: /assets/images/blog/authors/nirmal_manoj.png
+    image: /assets/images/blog/authors/nirmal_manoj.png
+
+emad_sohail:
+    name: Emad Sohail
+    bio: Emad Sohail (aka PremadeS) is a CS undergraduate student at ITU Lahore, Pakistan. He was a RSoC 2025 student who worked on improving the User Experience of Cutter.
+    github: https://github.com/PremadeS
+    image: /assets/images/blog/authors/emad_sohail.png

_posts/2025-10-04-integrating-the-rizin-mark-api-rsoc.md

@@ -0,0 +1,112 @@
+---
+layout: post
+title: "Integrating the Rizin Mark API - RSoC Project"
+date: 2025-10-04
+tags: ["Marks", "RSoC"]
+categories: ["Cutter", "Marks", "RSoC"]
+author: emad_sohail
+post_image: "/assets/images/blog/posts/inetgrating-the-rizin-mark-api-rsoc/cover.png"
+description: "Marks in Cutter are now visual and easier to manage with tooltips, colors, and overlapping support in the Hexdump. Read about the new feature implemented by Emad Sohail, an RSoC student"
+---
+
+As a second project of my RSoC internship, I worked on integrating the Rizin Mark API into Cutter to visually show the prescence of marks in the `Hexdump` widget.
+
+![Mark Complete](/assets/images/blog/posts/inetgrating-the-rizin-mark-api-rsoc/mark-complete.gif)
+
+You can find the write-up of my first project [here](https://cutter.re/shortcut-manager-rsoc)
+
+## **What Are Marks**
+
+**Marks** in Rizin let you label a range of memory addresses with a name, comment, or even a color. They’re a way to keep track of important regions in a binary.
+
+Refer to [RSoC 2025 - Adding Mark API](https://rizin.re/posts/rsoc-2025-mark-api/) for more details about **Marks**.
+
+## **Implementation**
+
+For now **Marks** are only available in the **Hexdump** widget
+
+### **Adding, Editing and Removing Marks**
+
+To make working with marks more user-friendly, we introduced a dedicated dialog in Cutter. This dialog, implemented in `MarkDialog`, takes user input and communicates with the `Core()` instance to add or edit marks. Through it, users can visually set the start and end addresses, give the mark a name, add a comment, and even pick a color.
+
+![Add mark dialog box](/assets/images/blog/posts/inetgrating-the-rizin-mark-api-rsoc/mark-add-dialog.png)
+
+Actions for adding, editing, and removing marks are integrated into the **context menu**.
+
+![Context menu actions for marks](/assets/images/blog/posts/inetgrating-the-rizin-mark-api-rsoc/mark-context-menu.png)
+
+A default shortcut key `M` was also introduced in `DefaultShortcuts` to quickly trigger the **Add Mark** action.
+
+### **Visualizing Marks**
+
+Once adding and editing marks was in place, the next step was to give them a proper visual representation. This happens directly inside the `Hexdump` widget. Before drawing the **Data bytes** and **ASCII** characters, the widget first queries the `Core()` instance for all mark items that overlap with the current **viewport**. These are collected in a `MarkDescription` container.
+
+```c
+struct MarkDescription
+{
+    RVA from;
+    RVA to;
+    QString name;
+    QString realname;
+    QString comment;
+    QColor color;
+};
+```
+
+Each mark is then rendered in its assigned color, and finally the **Data bytes** and **ASCII** characters are drawn on top, so the marks integrate smoothly into the **Hexdump** view.
+
+![Two highlighted marks](/assets/images/blog/posts/inetgrating-the-rizin-mark-api-rsoc/mark-highlight.png)
+
+### **Blending Overlapping Marks**
+
+To handle **overlapping Marks**, their colors are blended to create a combined color for the overlapping region. This is achieved by setting the alpha of each mark’s color to **50%**, allowing the `QPainter` object to automatically mix them when drawing the overlapped areas.
+
+![Two highlighted overlapping marks](/assets/images/blog/posts/inetgrating-the-rizin-mark-api-rsoc/mark-highlight-overlap.png)
+
+Here the **overlapping** region is highlighted by a subtle green color.
+
+### **Tooltip**
+
+To help distinguish between different marks, we use `QToolTip`. When the user hovers over a marked address, a **tooltip** appears showing a small colored circle along with the mark’s name.
+
+![Single mark tooltip](/assets/images/blog/posts/inetgrating-the-rizin-mark-api-rsoc/mark-tooltip.png)
+
+If **multiple** marks overlap at the same address, the tooltip lists them all line by line, with priority given to the most recently added mark.
+
+![Overlapping marks tooltip](/assets/images/blog/posts/inetgrating-the-rizin-mark-api-rsoc/mark-tooltip-overlap.png)
+
+The **tooltip** is designed to follow the cursor. This was achieved with a small trick: first set the `QToolTip` text to the intended text plus a trailing space, and then immediately update it with the actual text. This forces Qt to redraw the tooltip at the new cursor position while keeping the content unchanged.
+
+![Mark tooltip animation](/assets/images/blog/posts/inetgrating-the-rizin-mark-api-rsoc/mark-tooltip-animation.gif)
+
+### **Removing and Editing Overlapping Marks**
+
+Since our feature now supports overlapping marks, we needed a way to remove or edit a mark that is completely contained inside another mark. Previously, the only way to access such a mark was by first removing the marks on top of it and then re-adding them, which was inconvenient.
+
+To solve this, the **Remove** and **Edit** actions in the context menu now list all of the marks present at the selected address along with their names. This allows the user to directly choose which mark to edit or remove without disturbing the others.
+
+![Remove mark submenu](/assets/images/blog/posts/inetgrating-the-rizin-mark-api-rsoc/mark-remove-overlap.png)
+
+## **Challenges**
+
+Everything worked fine until we hit an issue: whenever the cursor moved inside a highlighted mark range, the background reverted to Cutter’s default color instead of staying with the mark’s highlight. This happened because the cursor redraw overwrote the background each time it moved.
+
+If there was only one mark at the cursor address, fixing this would be easy, just query the mark and repaint the background with its color. But since multiple marks can overlap at the same address, we needed a smarter approach. To solve this, we introduced a helper function `getBlendedMarksColorAt()` inside `CutterCore`, which calculates the final blended color for all marks at a given address.
+
+## **Future Improvments**
+
+A cool idea for future work could be to create another tab alongside the **Parsing** and **Information** tabs in the right panel, dedicated to **Marks**.
+This tab would display all added marks in a table-like view with their names, and allow quick interaction.
+
+Clicking on a mark would open its details (such as comment, color, etc.) and provide options to directly edit or remove it, without needing to use the right-click context menu.
+Additionally, double-clicking on a row could automatically move the **cursor** and **viewpoint** to the starting address of the selected mark, making navigation much faster and more intuitive.
+
+![Right pane highlighted with arrow and red box](/assets/images/blog/posts/inetgrating-the-rizin-mark-api-rsoc/mark-future-improvement.png)
+
+And also extending **Marks** support to different widgets (Disassembly, Graph etc).
+
+## **Conclusion**
+
+The integration of the Rizin Mark API in Cutter enables adding, editing, and managing overlapping marks directly in the Hexdump. With tooltips and context menu actions, it streamlines annotating binaries while leaving room for future enhancements. 
+
+This was no doubt a great learning experience and at the end I would like to thank [@xvilka](https://github.com/notxvilka) for this amazing oppurtunity and also [@karliss](https://github.com/karliss), [@deroad](https://github.com/wargio) for the help and guidance.

_posts/2025-10-04-shortcut-manager-rsoc.md

@@ -0,0 +1,60 @@
+---
+layout: post
+title: "Shortcut Manager - RSoC Project"
+date: 2025-10-04
+tags: ["Shortcuts", "RSoC"]
+categories: ["Cutter", "Shortcuts", "RSoC"]
+author: emad_sohail
+post_image: "/assets/images/blog/posts/shortcut-manager-rsoc/cover.png"
+description: "Introducing a centralized Shortcut Manager in Cutter for improved consistency and maintainability. Read about the improvements made possible by Emad Sohail, an RSoC student"
+---
+
+# **Shortcut Manager - RSoC Project**
+
+Greetings! I'm Emad Sohail (aka PremadeS), a 2nd-year CS undergraduate student at Information Technology University - Lahore. You can find me on [Github](https://github.com/PremadeS) and [LinkedIn](https://www.linkedin.com/in/emad-sohail-130b3b265/).
+
+This summer I worked on improving the user experience of Cutter. 
+
+This was the first project. The main objective of this project was to introduce a universal **Shortcut Manager** in Cutter and to provide a flexible setup that can support custom shortcuts in the future with minimal additions.
+
+You can find the write-up of my second project [here](https://cutter.re/integrating-the-rizin-mark-api-rsoc)
+
+## **Why a Shortcut Manager**
+
+Default key sequences, *also referred to here as shortcuts*, were previosuly defined in their respective classes. While this approach works if the codebase is small. However, it gets exceptionally difficult to manage as the project grows, making it hard to keep track of which shortcuts are assigned to which functions. On top of that, as the key sequences were scattered in different files there was no way to create a centralized view that allows the user to see the default shortcuts and their respective actions.  
+
+## **Design Goals**
+
+The **Shortcut Manager** was designed with three key goals:
+
+1) **Consistency:** Shortcuts should behave uniformly across the application, regardless of whether they originate from a `QAction` or a `QShortcut`
+2) **Maintainablity:** All of the default shortcuts must be at the same place, which allows the developers to quickly add, remove or edit key sequences without needing to look through multiple files 
+3) **Extensibility:** The system should provide a solid foundation that can be expanded in the future, enabling features like custom user-defined shortcuts
+
+## **Implementation**
+
+Default key sequences are stored in a `Shortcut` struct, each mapped to a unique ID within `shortcuts/DefaultShortcuts` using a **hashmap**. The `Shortcut` struct holds both the key sequence and a descriptive text string, along with a context string that is particularly useful for translations.
+
+Whenever a `QAction` or `QShortcut` inside any class wants to register a key sequence, it queries the `ShortcutManager` class through a singleton object defined by `Shortcuts()`, using the unique ID.
+
+The `ShortcutManager` then looks up the corresponding entry in the default shortcuts map. If a matching ID exists, it returns the associated key sequence; if not, it logs a warning and returns an empty `QKeySequence` object.
+
+![Shortcut manager process flowchart](/assets/images/blog/posts/shortcut-manager-rsoc/shortcut-registering-flowchart.png)
+
+To make the process even simpler, the `ShortcutManager` also provides utility methods that return fully configured `QAction` or `QShortcut` objects based on the given ID. This not only streamlines shortcut creation but also hides away the underlying complexity, keeping the codebase clean and consistent.
+
+A Default Shortcuts widget has also been introduced, allowing users to easily view all default key sequences alongside their corresponding actions. It also includes a search bar, making it simple to quickly find specific shortcuts or actions. [PR #3504](https://github.com/rizinorg/cutter/pull/3504/)
+
+![Cutter Shortcut Filter](/assets/images/blog/posts/shortcut-manager-rsoc/shortcut-widget-filter.gif)
+
+## **Future Improvements**
+
+While the **Shortcut Manager** already improves consistency and maintainability, it also lays the groundwork for more advanced functionality:
+
+**Custom Shortcuts:** In the future, users will be able to define and register their own shortcuts through Cutter’s interface.
+
+**Profiles and Configurations:** A logical next step would be to allow different sets of shortcuts for different profiles or workflows, making it easier to switch between tailored setups.
+
+## **Conclusion**
+
+The introduction of the **Shortcut Manager** marks an important step in making Cutter more user-friendly and maintainable. By centralizing shortcuts, we’ve eliminated fragmentation in the codebase while also opening the door to future enhancements. While the project itself was relatively small in terms of code changes and complexity, its impact and long-term benefits are substantial.