Click and Drag Actors

We've built the basic structure and the actor menu. Now, let's implement the ability to interact with the actors in that menu. The goal is to allow users to click and drag an actor type to eventually place it in the level.

This lesson covers the first part of drag-and-drop: initiating the drag and providing visual feedback. We'll modify our Actor class to recognize when it's been clicked.

Upon detecting a click, the Actor will dispatch a custom SDL_Event. We'll use SDL_RegisterEvents() to define this event type. Then, we'll introduce a new ActorTooltip class. This class will manage a second, specialized SDL_Window. This window will appear when the custom drag event is received, display the image of the actor being dragged, and follow the mouse cursor faithfully using SDL_GetGlobalMouseState() and SDL_SetWindowPosition().

We'll carefully select window flags to ensure it behaves like a proper tooltip.

By the end of this section, we’ll be able to click and drag on the actors in our actor menu. We’ll have a visual indicator follow our mouse as we drag our actor, even outside of our primary window:

Actor Dragging

To signal that the user has started dragging an actor from the menu, we need a way for the Actor instance to communicate this action. We'll achieve this by defining and registering a custom SDL event type specifically for this purpose.

1// Config.h
2// ...
3
4namespace UserEvents{
5#ifdef WITH_EDITOR
6  inline Uint32 ACTOR_DRAG{
7    SDL_RegisterEvents(1)};
8#endif
9}
10
11// ...

First, we'll add a HasMouseFocus() method to Actor to specifically check if the cursor is currently over that particular actor's area. This function will need to query the ParentScene to ensure the main window is active before checking the coordinates against the actor's Rect.

Because this new function relies on the full definition of Scene (which isn't available in Actor.h due to the forward declaration), we need to separate declaration from definition. We’ll add a new source file for this and, to keep our header file concise, we’ll move our HandleEvent() definition over to that new header file too.

We'll declare HasMouseFocus() and HandleEvent() in Actor.h and implement them in a corresponding Editor/Source/Actor.cpp file, where we can safely include Editor/Scene.h.

1// Editor/Actor.h
2// ...
3
4namespace Editor {
5class Scene;
6class Actor {
7public:
8  // ...
9  bool HasMouseFocus() const;
10  virtual void HandleEvent(const SDL_Event& E){}
11  virtual void HandleEvent(const SDL_Event& E);
12  // ...
13};
14}

Inside Editor/Source/Actor.cpp, the Actor::HasMouseFocus() function first defers to the scene: if the parent scene doesn’t have mouse focus, we know the Actor can’t possibly have mouse focus, so we return false. This ensures we only consider hover checks when the editor window is active. Assuming the scene has focus, SDL_GetMouseState() fetches the mouse coordinates within that scene’s window. These coordinates are then compared against the actor's boundaries defined by Rect.

If the coordinates lie within the horizontal range (Rect.x to Rect.x + Rect.w) and the vertical range (Rect.y to Rect.y + Rect.h), the actor is considered hovered, and true is returned. Otherwise, false indicates the mouse is elsewhere.

1// Editor/Actor.cpp
2#include "Editor/Actor.h"
3#include "Editor/Scene.h"
4
5using namespace Editor;
6
7bool Actor::HasMouseFocus() const {
8  if (!ParentScene.HasMouseFocus()) {
9    return false;
10  }
11
12  int x, y;
13  SDL_GetMouseState(&x, &y);
14
15  if (
16    x < Rect.x ||
17    x > Rect.x + Rect.w ||
18    y < Rect.y ||
19    y > Rect.y + Rect.h
20  ) {
21    return false;
22  }
23
24  return true;
25}

The Actor::HandleEvent() implementation filters for the specific interaction we care about: a left mouse button press (that is, where the event’s type is SDL_MOUSEBUTTONDOWN , and the SDL_MouseButtonEvent's button value is SDL_BUTTON_LEFT).

If both are true, it then also verifies HasMouseFocus() to confirm the click landed within this actor's bounds.

Upon confirmation, we prepare our custom event. An SDL_Event struct called DragEvent is initialized with the type UserEvents::ACTOR_DRAG.

The key piece of information – which actor was clicked – is attached by assigning this (a pointer to the current Actor object) to DragEvent.user.data1. This event, carrying the actor pointer, is then injected into the event queue via SDL_PushEvent(&DragEvent).

1// Editor/Actor.cpp
2// ...
3
4void Actor::HandleEvent(const SDL_Event& E) {
5  if (
6    E.type == SDL_MOUSEBUTTONDOWN &&
7    E.button.button == SDL_BUTTON_LEFT &&
8    HasMouseFocus()
9  ) {
10    SDL_Event DragEvent{UserEvents::ACTOR_DRAG};
11    DragEvent.user.data1 = this;
12    SDL_PushEvent(&DragEvent);
13  }
14}

Actor Tooltip

To make the dragging action clear, we need a visual indicator that follows the mouse. When the ACTOR_DRAG event occurs, we should display the image of the selected actor near the cursor.

The best way to ensure this indicator remains visible even if the mouse moves outside the main editor window is to use a separate, dedicated SDL_Window. This approach allows the tooltip to float freely above the main window and others.

SDL lets us create windows with special characteristics suitable for tooltips, which we’ll set up soon.

We will create an Editor::ActorTooltip class to manage this process. It will be responsible for:

• creating the tooltip SDL_Window with appropriate flags
• listening for the ACTOR_DRAG event
• showing/hiding the window when drag interactions begin and end
• during drag actions, continously moving the tooltip window to be near the the mouse cursor
• drawing the dragged actor's image onto its surface

Our functions to accomplish all of these tasks look like this, and we’ll walk through implementing them next:

1// Editor/ActorTooltip.h
2#pragma once
3#include <SDL.h>
4#include "Actor.h"
5
6namespace Editor{
7class Scene;
8
9class ActorTooltip {
10public:
11  ActorTooltip(Scene& ParentScene);
12  ~ActorTooltip();
13  ActorTooltip(const ActorTooltip&) = delete;
14  ActorTooltip& operator=(const ActorTooltip&)
15  = delete;
16  void Render();
17  void Tick(float DeltaTime);
18  void PositionWindow();
19  void HandleEvent(const SDL_Event& E);
20  void SetIsVisible(bool NewVisibility);
21
22  SDL_Surface* GetSurface() const {
23    return SDL_GetWindowSurface(SDLWindow);
24  }
25
26private:
27  bool isVisible{false};
28  SDL_Window* SDLWindow{nullptr};
29  Actor* DragActor{nullptr};
30  Scene& ParentScene;
31};
32}

ActorTooltip Constructor

The constructor for ActorTooltip, defined in its .cpp file, focuses on creating the specialized SDL_Window. The core is the call to SDL_CreateWindow(), where the last argument specifies the window's characteristics through flags combined with |.

Here's what each flag contributes:

• SDL_WINDOW_HIDDEN: Ensures the tooltip is initially hidden.
• SDL_WINDOW_TOOLTIP: Provides a hint to the window manager about the window's purpose.
• SDL_WINDOW_BORDERLESS: Creates a window without any standard decorations like title bars or borders.
• SDL_WINDOW_SKIP_TASKBAR: Excludes the window from the taskbar, typical for tooltips or temporary popups.
• SDL_WINDOW_ALWAYS_ON_TOP: Keeps the tooltip window rendered above the main application window and potentially other applications.

The values we provide for the title, size and position arguments to SDL_CreateWindow() aren’t important - we’ll just use some placeholder values. The borderless nature makes the title mostly irrelevant, and subsequent code will dynamically manage the tooltip's position and size when it becomes visible.

1// Editor/Source/ActorTooltip.cpp
2#include "Editor/ActorTooltip.h"
3#include "Editor/Scene.h"
4
5using namespace Editor;
6
7ActorTooltip::ActorTooltip(Scene& ParentScene)
8  : ParentScene{ParentScene}
9{
10  SDLWindow = SDL_CreateWindow(
11    "Tooltip",
12    SDL_WINDOWPOS_UNDEFINED,
13    SDL_WINDOWPOS_UNDEFINED,
14    100,
15    100,
16    SDL_WINDOW_HIDDEN
17    | SDL_WINDOW_TOOLTIP
18    | SDL_WINDOW_BORDERLESS
19    | SDL_WINDOW_SKIP_TASKBAR
20    | SDL_WINDOW_ALWAYS_ON_TOP
21  );
22  CheckSDLError("Creating Tooltip Window");
23}

1// Editor/Source/ActorTooltip.cpp
2#ifdef _WIN32
3// Windows API
4#include <windows.h>
5// SDL system window manager hooks
6#include <SDL_syswm.h>
7#endif
8#include "Editor/ActorTooltip.h"
9#include "Editor/Scene.h"
10
11using namespace Editor;
12
13ActorTooltip::ActorTooltip(Scene& ParentScene)
14  : ParentScene{ParentScene}
15{
16  SDLWindow = SDL_CreateWindow(
17    "Tooltip",
18    SDL_WINDOWPOS_UNDEFINED,
19    SDL_WINDOWPOS_UNDEFINED,
20    100,
21    100,
22    SDL_WINDOW_HIDDEN
23    | SDL_WINDOW_TOOLTIP
24    | SDL_WINDOW_BORDERLESS
25    | SDL_WINDOW_SKIP_TASKBAR
26    | SDL_WINDOW_ALWAYS_ON_TOP
27  );
28  CheckSDLError("Creating Tooltip Window");
29  
30#ifdef _WIN32
31  SDL_SysWMinfo wmInfo;
32  SDL_GetVersion(&wmInfo.version);
33  SDL_GetWindowWMInfo(SDLWindow, &wmInfo);
34
35  HWND hwnd{wmInfo.info.win.window};
36  LONG style{GetWindowLong(hwnd, GWL_EXSTYLE)};
37  SetWindowLong(hwnd, GWL_EXSTYLE,
38    style |= WS_EX_NOACTIVATE
39  );
40#endif
41}

1// This does not exist in SDL2 - only SDL3
2SDL_SetWindowFocusable(SomeWindow, false);

ActorTooltip Destructor and Copy Semantics

Just like our main Editor::Window, the ActorTooltip class manages an SDL_Window resource. Therefore, it needs a destructor (~ActorTooltip) to ensure proper cleanup when an ActorTooltip object goes out of scope or is destroyed.

In our program, we expect our Scene and therefore our Tooltip to be alive for the entire duration of our program, so this shouldn’t happen, but it’s etter to be proactive.

The destructor checks if SDL's video subsystem is still initialized using SDL_WasInit(SDL_INIT_VIDEO). If SDL has already shut down, the windows would have been cleaned up globally, so we don’t need to do anything.

Otherwise, if the SDLWindow pointer is valid (not nullptr), we explicitly destroy the tooltip window using SDL_DestroyWindow().

1// Editor/Source/ActorTooltip.cpp
2// ...
3
4ActorTooltip::~ActorTooltip() {
5  if (!SDL_WasInit(SDL_INIT_VIDEO)) return;
6  if (SDLWindow) {
7    SDL_DestroyWindow(SDLWindow);
8  }
9}

ActorTooltip Positioning

The PositionWindow() function is responsible for moving the tooltip window to follow the mouse cursor. We want the tooltip to appear right next to the cursor, creating the illusion that the user is dragging the actor image directly.

It uses SDL_GetGlobalMouseState() to get the current mouse coordinates (x, y) relative to the entire screen, not just our application window. It then calls SDL_SetWindowPosition(), passing the SDLWindow pointer and these global x and y coordinates, instantly repositioning the tooltip window to the cursor's location.

1// Editor/Source/ActorTooltip.cpp
2// ...
3
4void ActorTooltip::PositionWindow() {
5  int x, y;
6  SDL_GetGlobalMouseState(&x, &y);
7  SDL_SetWindowPosition(SDLWindow, x, y);
8}

ActorTooltip Visibility

We need a controlled way to show and hide the tooltip window. Creating and destroying windows frequently is inefficient, so toggling visibility is preferred.

The SetIsVisible() method manages this state. It takes a boolean Visible argument. It updates the internal isVisible flag and then calls either SDL_ShowWindow() if Visible is true, or SDL_HideWindow() if Visible is false:

This synchronizes the internal state with the actual visibility of the SDL_Window.

1// Editor/Source/ActorTooltip.cpp
2// ...
3
4void ActorTooltip::SetIsVisible(bool Visible) {
5  isVisible = Visible;
6  if (isVisible) {
7    SDL_ShowWindow(SDLWindow);
8  } else {
9    SDL_HideWindow(SDLWindow);
10  }
11}

ActorTooltip Event Handling

The ActorTooltip::HandleEvent() method listens for the specific event that signals the start of a drag: our custom UserEvents::ACTOR_DRAG.

When it receives an event of this type, it knows it needs to become active. It first calls SetIsVisible(true) to make the tooltip window appear.

It then retrieves the pointer to the Actor being dragged, which we stored in E.user.data1 when pushing the event. It casts this void* back to an Actor* and stores it in the DragActor member variable for later use (e.g., rendering its image).

1// Editor/Source/ActorTooltip.cpp
2// ...
3
4void ActorTooltip::HandleEvent(
5  const SDL_Event& E
6) {
7  using namespace UserEvents;
8  if (E.type == ACTOR_DRAG) {
9    SetIsVisible(true);
10    DragActor = static_cast<Actor*>(
11      E.user.data1
12    );
13  }
14}

ActorTooltip Ticking

In the Tick() function, we handle the continuous aspects of the tooltip's behavior. The initial if (!isVisible) return; ensures we only process logic when the tooltip should be active.

The main task is to determine if the drag should continue or end. We get the current mouse button states using SDL_GetGlobalMouseState(). We test if the bit corresponding to the left mouse button (SDL_BUTTON_LEFT) is set in the returned mask.

If it's not set, the user has let go, so we hide the tooltip using SetIsVisible(false). If the button is still held down, the drag continues, and we call PositionWindow() to keep the tooltip aligned with the cursor.

1// Editor/Source/ActorTooltip.cpp
2// ...
3
4void ActorTooltip::Tick(float DeltaTime) {
5  if (!isVisible) return;
6
7  auto Buttons{
8    SDL_GetGlobalMouseState(
9      nullptr, nullptr)};
10  if (!(Buttons & SDL_BUTTON_LEFT)) {
11    SetIsVisible(false);
12  } else {
13    PositionWindow();
14  }
15}

ActorTooltip Rendering

The ActorTooltip::Render() function is responsible for drawing the content inside the tooltip window. For now, we haven't added the logic to draw the actor's image yet.

We'll implement the actual rendering in the next steps. At this stage, we provide an empty function body just so the code compiles. This allows us to integrate the ActorTooltip into the Scene's render loop without causing errors, even though it won't visually draw anything yet.

1// Editor/Source/ActorTooltip.cpp
2// ...
3
4void ActorTooltip::Render() {
5  // We'll implement this next...
6}

Adding the Tooltip to the Scene

To integrate our new tooltip system, we need to instantiate ActorTooltip within the Editor::Scene. We'll add it as a member variable and ensure its HandleEvent(), Tick(), and Render() methods are called from the corresponding Scene methods.

1// Editor/Scene.h
2// ...
3#include "ActorTooltip.h"
4
5namespace Editor{
6class Scene {
7  // ...
8  void HandleEvent(const SDL_Event& E) {
9    ActorShelf.HandleEvent(E);
10    TooltipWindow.HandleEvent(E);
11  }
12
13  void Tick(float DeltaTime) {
14    ActorShelf.Tick(DeltaTime);
15    TooltipWindow.Tick(DeltaTime);
16  }
17
18  void Render(SDL_Surface* Surface) {
19    ActorShelf.Render(Surface);
20    TooltipWindow.Render();
21  }
22
23 private:
24  ActorTooltip TooltipWindow{*this};
25  // ...
26};
27}

Rendering the Actor within the Tooltip

Our tooltip window exists, appears, follows the mouse, and disappears correctly. Now we need to draw the actual actor image inside it. To do this, the ActorTooltip needs access to information from the Actor instance it's currently tracking (DragActor).

Specifically, the tooltip needs:

1. The Image object associated with the actor to render it.
2. The dimensions (w, h) of the actor to size the tooltip window correctly.
3. A way to calculate the offset between where the user clicked on the actor and the actor's top-left corner, for a smoother drag feel.

We'll add getter methods and a new member variable (DragOffset) to the Actor class to provide this information.

1// Editor/Actor.h
2#pragma once
3#include <SDL.h>
4#include "Image.h"
5
6namespace Editor {
7class Scene;
8class Actor {
9 public:
10  // ...
11  const SDL_Rect& GetRect() const {
12    return Rect;
13  }
14
15  const SDL_Point& GetDragOffset() const {
16    return DragOffset;
17  }
18
19  const Image& GetArt() const {
20    return Art;
21  }
22
23protected:
24  // ...
25  SDL_Point DragOffset{0, 0};
26};
27}

Using Drag Offset

Our DragOffset value let’s us remember exactly where on the actor the user clicked to start dragging. Remembering this position is not technically necessary, but we can use it to improve the user experience.

If we don’t store this offset, we can still position the tooltip next to the mouse, but its position will be slightly different to where the user started dragging. Perhaps we’d position the tooltip at the centre of the cursor, or the top left for example. Either way, it’s unlikely to match exactly where the user clicked:

But if we remember the drag offset, we can use that value to subtly adjust the position of our tooltip window, creating the effect of the actor "sticking" to the mouse more accurately.

When the user starts dragging our actor, we’ll calculate and store their mouse position relative to the top left of our actor’s rectangle:

1// Editor/Source/Actor.cpp
2// ...
3
4void Actor::HandleEvent(const SDL_Event& E) {
5  if (
6    E.type == SDL_MOUSEBUTTONDOWN &&
7    E.button.button == SDL_BUTTON_LEFT &&
8    HasMouseFocus()
9  ) {
10    DragOffset.x = E.button.x - Rect.x;
11    DragOffset.y = E.button.y - Rect.y;
12
13    SDL_Event DragEvent{UserEvents::ACTOR_DRAG};
14    DragEvent.user.data1 = this;
15    SDL_PushEvent(&DragEvent);
16  }
17}

We’ll now modify ActorTooltip::PositionWindow() to incorporate the DragOffset. Before setting the window position, we retrieve the offset from the DragActor using its new GetDragOffset() method.

We then subtract the retrieved DragOffsetX and DragOffsetY from the global mouse coordinates (x, y) before passing them to SDL_SetWindowPosition(). This adjustment ensures the tooltip window is positioned such that the original click point on the actor aligns with the current mouse cursor, creating the desired "sticky" dragging effect.

1// Editor/Source/ActorTooltip.cpp
2// ...
3
4void ActorTooltip::PositionWindow() {
5  int x, y;
6  SDL_GetGlobalMouseState(&x, &y);
7
8  auto [DragOffsetX, DragOffsetY]{
9    DragActor->GetDragOffset()
10  };
11
12  SDL_SetWindowPosition(
13    SDLWindow,
14    x - DragOffsetX,
15    y - DragOffsetY
16  );
17}

Using GetRect()

The tooltip window needs to be the same size as the actor being dragged. When the ACTOR_DRAG event is handled in ActorTooltip::HandleEvent(), right after identifying the DragActor, we can now use its GetRect() method.

We call SDL_SetWindowSize(), passing it the SDLWindow pointer. We extract the width (w) and height (h) from the SDL_Rect returned by DragActor->GetRect() and use these values as the new dimensions for the tooltip window.

This ensures the tooltip perfectly matches the size of the actor image it will display.

1// Editor/Source/ActorTooltip.cpp
2// ...
3
4void ActorTooltip::HandleEvent(
5  const SDL_Event& E) {
6  using namespace UserEvents;
7  if (E.type == ACTOR_DRAG) {
8    DragActor = static_cast<Actor*>(
9      E.user.data1
10    );
11    SDL_SetWindowSize(
12      SDLWindow,
13      DragActor->GetRect().w,
14      DragActor->GetRect().h
15    );
16    SetIsVisible(true);
17  }
18}

Using GetArt()

Finally, our Actor's new GetArt() method lets our tooltip retrieve the Image associated with the actor being dragged. Let’s render that image within our tooltip.

Our image should take up the full size of our tooltip’s window surface, so we’ll render it at position (0, 0) with the width and height provided by the DragActor's GetRect() function.

In our case, that is also the same width and height as the tooltip window itself, as we set its size to these values when our drag event started.

Remember, to see our changes to a window surface, we need to call SDL_UpdateWindowSurface(). In this case, we’re not going to be rendering anything else to our tooltip’s surface, so we can call this at the end of our Render() function:

1// Editor/Source/ActorTooltip.cpp
2// ...
3
4void ActorTooltip::Render() {
5  if (!isVisible) return;
6  DragActor->GetArt().Render(
7    GetSurface(),
8    SDL_Rect{
9      0, 0,
10      DragActor->GetRect().w,
11      DragActor->GetRect().h
12    });
13
14  SDL_UpdateWindowSurface(SDLWindow);
15}

Running our program, we should now see that we can click and drag actors from our menu, and even drag them outside of our window:

Complete Code

Our new ActorTooltip class is provided below:

1#pragma once
2#include <SDL.h>
3#include "Actor.h"
4
5namespace Editor{
6class Scene;
7
8class ActorTooltip {
9public:
10  ActorTooltip(Scene& ParentScene);
11  ~ActorTooltip();
12  ActorTooltip(const ActorTooltip&) = delete;
13  ActorTooltip& operator=(const ActorTooltip&)
14    = delete;
15  void Render();
16  void Tick(float DeltaTime);
17  void PositionWindow();
18  void HandleEvent(const SDL_Event& E);
19  void SetIsVisible(bool NewVisibility);
20
21  SDL_Surface* GetSurface() const {
22    return SDL_GetWindowSurface(SDLWindow);
23  }
24
25private:
26  bool isVisible{false};
27  SDL_Window* SDLWindow{nullptr};
28  Actor* DragActor{nullptr};
29  Scene& ParentScene;
30};
31}

1#include "Editor/ActorTooltip.h"
2#include "Editor/Scene.h"
3
4using namespace Editor;
5
6ActorTooltip::ActorTooltip(Scene& ParentScene)
7  : ParentScene{ParentScene} {
8  SDLWindow = SDL_CreateWindow(
9    "Tooltip",
10    SDL_WINDOWPOS_UNDEFINED,
11    SDL_WINDOWPOS_UNDEFINED,
12    100,
13    100,
14    SDL_WINDOW_HIDDEN
15    | SDL_WINDOW_TOOLTIP
16    | SDL_WINDOW_BORDERLESS
17    | SDL_WINDOW_SKIP_TASKBAR
18    | SDL_WINDOW_ALWAYS_ON_TOP
19  );
20  CheckSDLError("Creating Tooltip Window");
21}
22
23ActorTooltip::~ActorTooltip() {
24  if (!SDL_WasInit(SDL_INIT_VIDEO)) return;
25  if (SDLWindow) {
26    SDL_DestroyWindow(SDLWindow);
27  }
28}
29
30void ActorTooltip::Render() {
31  if (!isVisible) return;
32  DragActor->GetArt().Render(
33    GetSurface(),
34    SDL_Rect{
35      0, 0,
36      DragActor->GetRect().w,
37      DragActor->GetRect().h
38    });
39
40  SDL_UpdateWindowSurface(SDLWindow);
41}
42
43void ActorTooltip::Tick(float DeltaTime) {
44  if (!isVisible) return;
45
46  auto Buttons{
47    SDL_GetGlobalMouseState(
48      nullptr, nullptr)};
49  if (!(Buttons & SDL_BUTTON_LEFT)) {
50    SetIsVisible(false);
51  } else { PositionWindow(); }
52}
53
54void ActorTooltip::PositionWindow() {
55  int x, y;
56  SDL_GetGlobalMouseState(&x, &y);
57
58  auto [DragOffsetX, DragOffsetY]{
59    DragActor->GetDragOffset()
60  };
61
62  SDL_SetWindowPosition(
63    SDLWindow,
64    x - DragOffsetX,
65    y - DragOffsetY
66  );
67}
68
69void ActorTooltip::HandleEvent(
70  const SDL_Event& E) {
71  using namespace UserEvents;
72  if (E.type == ACTOR_DRAG) {
73    DragActor = static_cast<Actor*>(
74      E.user.data1
75    );
76    SDL_SetWindowSize(
77      SDLWindow,
78      DragActor->GetRect().w,
79      DragActor->GetRect().h
80    );
81    SetIsVisible(true);
82  }
83}
84
85void ActorTooltip::SetIsVisible(bool Visible) {
86  isVisible = Visible;
87  if (isVisible) {
88    SDL_ShowWindow(SDLWindow);
89  } else { SDL_HideWindow(SDLWindow); }
90}

We also updated our Actor class with some new capabilities, and added a new source file for implementing some of those functions:

1#pragma once
2#include <SDL.h>
3#include "Image.h"
4
5namespace Editor {
6class Scene;
7class Actor {
8 public:
9  Actor(
10    Scene& ParentScene,
11    const SDL_Rect& Rect,
12    Image& Image
13  ) : ParentScene{ParentScene},
14      Rect{Rect},
15      Art{Image}
16  {}
17
18  bool HasMouseFocus() const;
19  virtual void HandleEvent(const SDL_Event& E);
20
21  void Tick(float DeltaTime) {}
22
23  void Render(SDL_Surface* Surface) {
24    Art.Render(Surface, Rect);
25  }
26
27  const SDL_Rect& GetRect() const {
28    return Rect;
29  }
30
31  const SDL_Point& GetDragOffset() const {
32    return DragOffset;
33  }
34
35  const Image& GetArt() const {
36    return Art;
37  }
38
39protected:
40  Scene& ParentScene;
41  SDL_Rect Rect;
42  Image& Art;
43  SDL_Point DragOffset{0, 0};
44};
45}

1#include "Editor/Actor.h"
2#include "Editor/Scene.h"
3
4using namespace Editor;
5
6void Actor::HandleEvent(const SDL_Event& E) {
7  if (
8    E.type == SDL_MOUSEBUTTONDOWN &&
9    E.button.button == SDL_BUTTON_LEFT &&
10    HasMouseFocus()
11  ) {
12    DragOffset.x = E.button.x - Rect.x;
13    DragOffset.y = E.button.y - Rect.y;
14
15    SDL_Event DragEvent{UserEvents::ACTOR_DRAG};
16    DragEvent.user.data1 = this;
17    SDL_PushEvent(&DragEvent);
18  }
19}
20
21bool Actor::HasMouseFocus() const {
22  if (!ParentScene.HasMouseFocus()) {
23    return false;
24  }
25
26  int x, y;
27  SDL_GetMouseState(&x, &y);
28
29  if (
30    x < Rect.x ||
31    x > Rect.x + Rect.w ||
32    y < Rect.y ||
33    y > Rect.y + Rect.h
34  ) { return false; }
35
36  return true;
37}

We updated our Scene to add an instance of our ActorTooltip, and we updated our Config.h to register a custom event type:

1#pragma once
2#include <SDL.h>
3#include "ActorMenu.h"
4#include "ActorTooltip.h"
5#include "AssetManager.h"
6#include "Window.h"
7
8namespace Editor{
9class Scene {
10 public:
11  Scene(Window& ParentWindow)
12  : ParentWindow{ParentWindow}
13  {}
14
15  void HandleEvent(const SDL_Event& E) {
16    ActorShelf.HandleEvent(E);
17    TooltipWindow.HandleEvent(E);
18  }
19
20  void Tick(float DeltaTime) {
21    ActorShelf.Tick(DeltaTime);
22    TooltipWindow.Tick(DeltaTime);
23  }
24
25  void Render(SDL_Surface* Surface) {
26    ActorShelf.Render(Surface);
27    TooltipWindow.Render();
28  }
29
30  AssetManager& GetAssets() {
31    return Assets;
32  }
33
34  bool HasMouseFocus() const {
35    return ParentWindow.HasMouseFocus();
36  }
37
38  Window& GetWindow() const {
39    return ParentWindow;
40  }
41
42 private:
43  ActorMenu ActorShelf{*this};
44  ActorTooltip TooltipWindow{*this};
45  Window& ParentWindow;
46  AssetManager Assets;
47};
48}

1#pragma once
2#include <iostream>
3#include <SDL.h>
4#include <string>
5#include <vector>
6
7namespace UserEvents{
8#ifdef WITH_EDITOR
9  inline Uint32 ACTOR_DRAG{
10    SDL_RegisterEvents(1)};
11#endif
12}
13
14namespace Config {
15inline const std::vector BUTTON_COLORS{
16  SDL_Color{15, 15, 15, 255},  // Normal
17  SDL_Color{15, 155, 15, 255}, // Hover
18  SDL_Color{225, 15, 15, 255}, // Active
19  SDL_Color{60, 60, 60, 255}   // Disabled
20};
21
22inline constexpr SDL_Color FONT_COLOR{
23  255, 255, 255, 255};
24
25inline const std::string FONT{
26  "Assets/Rubik-SemiBold.ttf"};
27}
28
29#ifdef WITH_EDITOR
30namespace Config::Editor {
31// Window
32inline const std::string WINDOW_TITLE{"Editor"};
33inline const int WINDOW_WIDTH{730};
34inline const int WINDOW_HEIGHT{300};
35inline const SDL_Color WINDOW_BACKGROUND{
36  35, 35, 35, 255};
37
38// ActorMenu
39inline const int ACTOR_MENU_WIDTH{70};
40inline const int ACTOR_MENU_POSITION_X{
41  WINDOW_WIDTH - ACTOR_MENU_WIDTH};
42inline const SDL_Color ACTOR_MENU_BACKGROUND{
43  15, 15, 15, 255};
44inline const int PADDING{10};
45}
46#endif
47
48inline void CheckSDLError(
49  const std::string& Msg) {
50#ifdef CHECK_ERRORS
51  const char* error = SDL_GetError();
52  if (*error != '\0') {
53    std::cerr << Msg << " Error: "
54      << error << '\n';
55    SDL_ClearError();
56  }
57#endif
58}

Summary

This lesson focused on making the ActorMenu interactive by adding drag capabilities. We enabled users to click on an actor, triggering a visual feedback mechanism.

The core components added were a custom ACTOR_DRAG event and the ActorTooltip class. The Actor now detects clicks and pushes this event, carrying a pointer to itself.

The ActorTooltip listens for this event, creates a borderless, always-on-top window, sizes it appropriately, and displays the dragged actor's image. This tooltip window dynamically follows the global mouse cursor until the mouse button is released.

We reviewed how to:

• Define custom events for application-specific signaling.
• Use SDL_WindowFlags to create specialized windows (tooltips).
• Manage window visibility and position dynamically.
• Render content to a secondary window surface and update it.
• Implement a drag offset for a more natural user experience.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course