Skip to content

Commit 96b7b1d

Browse files
prevterprevter
committed
port to new events and tasks
1 parent dc0673d commit 96b7b1d

File tree

9 files changed

+106
-105
lines changed

9 files changed

+106
-105
lines changed

‎include/API.hpp‎

Lines changed: 30 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -27,36 +27,30 @@ namespace devtools {
2727
template <typename T>
2828
concept UnderlyingIntegral = std::is_integral_v<T> || std::is_integral_v<std::underlying_type_t<T>>;
2929

30-
struct RegisterNodeEvent final : geode::Event {
31-
RegisterNodeEvent(std::function<void(cocos2d::CCNode*)>&& callback)
32-
: callback(std::move(callback)) {}
33-
std::function<void(cocos2d::CCNode*)> callback;
30+
struct RegisterNodeEvent final : geode::SimpleEvent<RegisterNodeEvent, geode::Function<void(cocos2d::CCNode*)>> {
31+
using SimpleEvent::SimpleEvent;
3432
};
3533

3634
template <typename T>
37-
struct PropertyFnEvent final : geode::Event {
38-
PropertyFnEvent() {}
35+
struct PropertyFnEvent final : geode::SimpleEvent<PropertyFnEvent<T>, bool(*&)(const char* name, T&)> {
3936
using Fn = bool(const char* name, T&);
40-
Fn* fn = nullptr;
37+
using geode::SimpleEvent<PropertyFnEvent, Fn*&>::SimpleEvent;
4138
};
4239

43-
struct DrawLabelFnEvent final : geode::Event {
44-
DrawLabelFnEvent() {}
40+
struct DrawLabelFnEvent final : geode::SimpleEvent<DrawLabelFnEvent, void(*&)(const char* text)> {
4541
using Fn = void(const char* text);
46-
Fn* fn = nullptr;
42+
using SimpleEvent::SimpleEvent;
4743
};
4844

4945
template <typename T>
50-
struct EnumerableFnEvent final : geode::Event {
51-
EnumerableFnEvent() {}
52-
using Fn = bool(const char* label, T* value, std::span<std::pair<T, const char*> const> items);
53-
Fn* fn = nullptr;
46+
struct EnumerableFnEvent final : geode::SimpleEvent<EnumerableFnEvent<T>, bool(*&)(const char* label, T* value, std::span<std::pair<T, const char*> const>)> {
47+
using Fn = bool(const char* label, T* value, std::span<std::pair<T, const char*> const>);
48+
using geode::SimpleEvent<EnumerableFnEvent, Fn*&>::SimpleEvent;
5449
};
5550

56-
struct ButtonFnEvent final : geode::Event {
57-
ButtonFnEvent() {}
51+
struct ButtonFnEvent final : geode::SimpleEvent<ButtonFnEvent, bool(*&)(const char* label)> {
5852
using Fn = bool(const char* label);
59-
Fn* fn = nullptr;
53+
using SimpleEvent::SimpleEvent;
6054
};
6155

6256
/// @brief Checks if DevTools is currently loaded.
@@ -75,12 +69,11 @@ namespace devtools {
7569
auto devtools = geode::Loader::get()->getInstalledMod("geode.devtools");
7670
if (!devtools) return;
7771

78-
new geode::EventListener(
79-
[callback = std::forward<F>(callback)](geode::ModStateEvent*) {
72+
geode::ModStateEvent(geode::ModEventType::Loaded, devtools).listen(
73+
[callback = std::forward<F>(callback)]() {
8074
callback();
81-
},
82-
geode::ModStateFilter(devtools, geode::ModEventType::Loaded)
83-
);
75+
}
76+
).leak();
8477
}
8578
}
8679

@@ -89,11 +82,11 @@ namespace devtools {
8982
/// @see `devtools::property`, `devtools::label`, `devtools::enumerable`, `devtools::button`
9083
template <typename T, std::invocable<std::remove_pointer_t<T>*> F> requires IsCCNode<T>
9184
void registerNode(F&& callback) {
92-
RegisterNodeEvent([callback = std::forward<F>(callback)](cocos2d::CCNode* node) {
85+
RegisterNodeEvent().send([callback = std::forward<F>(callback)](cocos2d::CCNode* node) {
9386
if (auto casted = geode::cast::typeinfo_cast<std::remove_pointer_t<T>*>(node)) {
9487
callback(casted);
9588
}
96-
}).post();
89+
});
9790
}
9891

9992
/// @brief Renders a property editor for the given value in the DevTools UI.
@@ -104,9 +97,9 @@ namespace devtools {
10497
template <typename T> requires SupportedProperty<T>
10598
bool property(const char* name, T& prop) {
10699
static auto fn = ([] {
107-
PropertyFnEvent<T> event;
108-
event.post();
109-
return event.fn;
100+
typename PropertyFnEvent<T>::Fn* fnPtr = nullptr;
101+
PropertyFnEvent<T>().send(fnPtr);
102+
return fnPtr;
110103
})();
111104
return fn ? fn(name, prop) : false;
112105
}
@@ -116,9 +109,9 @@ namespace devtools {
116109
/// @warning This function should only ever be called from within a registered node callback.
117110
inline void label(const char* text) {
118111
static auto fn = ([] {
119-
DrawLabelFnEvent event;
120-
event.post();
121-
return event.fn;
112+
DrawLabelFnEvent::Fn* fnPtr = nullptr;
113+
DrawLabelFnEvent().send(fnPtr);
114+
return fnPtr;
122115
})();
123116
if (fn) fn(text);
124117
}
@@ -133,9 +126,9 @@ namespace devtools {
133126
bool enumerable(const char* label, T& value, std::initializer_list<std::pair<T, const char*>> items) {
134127
using ValueType = std::underlying_type_t<T>;
135128
static auto fn = ([] {
136-
EnumerableFnEvent<ValueType> event;
137-
event.post();
138-
return event.fn;
129+
typename EnumerableFnEvent<ValueType>::Fn* fnPtr = nullptr;
130+
EnumerableFnEvent<ValueType>().send(fnPtr);
131+
return fnPtr;
139132
})();
140133
return fn ? fn(
141134
label,
@@ -153,9 +146,9 @@ namespace devtools {
153146
/// @warning This function should only ever be called from within a registered node callback.
154147
inline bool button(const char* label) {
155148
static auto fn = ([] {
156-
ButtonFnEvent event;
157-
event.post();
158-
return event.fn;
149+
ButtonFnEvent::Fn* fnPtr = nullptr;
150+
ButtonFnEvent().send(fnPtr);
151+
return fnPtr;
159152
})();
160153
return fn ? fn(label) : false;
161154
}
@@ -201,7 +194,7 @@ namespace devtools {
201194
template <UnderlyingIntegral T, UnderlyingIntegral U>
202195
bool radio(char const* label, T& current, U value) {
203196
return radio(label, reinterpret_cast<int&>(current), reinterpret_cast<int&>(value));
204-
}
197+
}
205198

206199
inline void inputMultiline(char const* label, std::string& text) GEODE_EVENT_EXPORT_NORES(&inputMultiline, (label, text));
207200
}

‎src/API.cpp‎

Lines changed: 39 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ using namespace geode::prelude;
88

99
template <typename T>
1010
static void handleType() {
11-
new EventListener<EventFilter<devtools::PropertyFnEvent<T>>>(+[](devtools::PropertyFnEvent<T>* event) {
11+
devtools::PropertyFnEvent<T>().listen([](typename devtools::PropertyFnEvent<T>::Fn*& fnPtr) {
1212
constexpr bool isSigned = std::is_signed_v<T>;
1313
constexpr ImGuiDataType dataType =
1414
std::is_same_v<T, float> ? ImGuiDataType_Float :
@@ -17,14 +17,14 @@ static void handleType() {
1717
sizeof(T) == 2 ? (isSigned ? ImGuiDataType_S16 : ImGuiDataType_U16) :
1818
sizeof(T) == 4 ? (isSigned ? ImGuiDataType_S32 : ImGuiDataType_U32) :
1919
isSigned ? ImGuiDataType_S64 : ImGuiDataType_U64;
20-
event->fn = +[](const char* name, T& prop) {
20+
fnPtr = +[](const char* name, T& prop) {
2121
return ImGui::DragScalar(name, dataType, &prop);
2222
};
2323
return ListenerResult::Stop;
24-
});
24+
}).leak();
2525

26-
new EventListener<EventFilter<devtools::EnumerableFnEvent<T>>>(+[](devtools::EnumerableFnEvent<T>* event) {
27-
event->fn = +[](const char* label, T* value, std::span<std::pair<T, const char*> const> items) {
26+
devtools::EnumerableFnEvent<T>().listen([](typename devtools::EnumerableFnEvent<T>::Fn*& fnPtr) {
27+
fnPtr = +[](const char* label, T* value, std::span<std::pair<T, const char*> const> items) {
2828
ImGui::Text("%s:", label);
2929
size_t i = 0;
3030
bool changed = false;
@@ -41,7 +41,7 @@ static void handleType() {
4141
return changed;
4242
};
4343
return ListenerResult::Stop;
44-
});
44+
}).leak();
4545
}
4646

4747
void devtools::newLine() {
@@ -73,10 +73,10 @@ void devtools::inputMultiline(const char* label, std::string& str) {
7373
}
7474

7575
$execute {
76-
new EventListener<EventFilter<devtools::RegisterNodeEvent>>(+[](devtools::RegisterNodeEvent* event) {
77-
DevTools::get()->addCustomCallback(std::move(event->callback));
76+
devtools::RegisterNodeEvent().listen([](Function<void(CCNode*)> callback) {
77+
DevTools::get()->addCustomCallback(std::move(callback));
7878
return ListenerResult::Stop;
79-
});
79+
}).leak();
8080

8181
// Scalars & Enums
8282
handleType<char>();
@@ -93,24 +93,24 @@ void devtools::inputMultiline(const char* label, std::string& str) {
9393
handleType<double>();
9494

9595
// checkbox
96-
new EventListener<EventFilter<devtools::PropertyFnEvent<bool>>>(+[](devtools::PropertyFnEvent<bool>* event) {
97-
event->fn = +[](const char* name, bool& prop) {
96+
devtools::PropertyFnEvent<bool>().listen([](devtools::PropertyFnEvent<bool>::Fn*& fnPtr) {
97+
fnPtr = +[](const char* name, bool& prop) {
9898
return ImGui::Checkbox(name, &prop);
9999
};
100100
return ListenerResult::Stop;
101-
});
101+
}).leak();
102102

103103
// string
104-
new EventListener<EventFilter<devtools::PropertyFnEvent<std::string>>>(+[](devtools::PropertyFnEvent<std::string>* event) {
105-
event->fn = +[](const char* name, std::string& prop) {
104+
devtools::PropertyFnEvent<std::string>().listen([](devtools::PropertyFnEvent<std::string>::Fn*& fnPtr) {
105+
fnPtr = +[](const char* name, std::string& prop) {
106106
return ImGui::InputText(name, &prop);
107107
};
108108
return ListenerResult::Stop;
109-
});
109+
}).leak();
110110

111111
// colors
112-
new EventListener<EventFilter<devtools::PropertyFnEvent<ccColor3B>>>(+[](devtools::PropertyFnEvent<ccColor3B>* event) {
113-
event->fn = +[](const char* name, ccColor3B& prop) {
112+
devtools::PropertyFnEvent<ccColor3B>().listen([](devtools::PropertyFnEvent<ccColor3B>::Fn*& fnPtr) {
113+
fnPtr = +[](const char* name, ccColor3B& prop) {
114114
auto color = ImVec4(
115115
prop.r / 255.f,
116116
prop.g / 255.f,
@@ -126,9 +126,9 @@ void devtools::inputMultiline(const char* label, std::string& str) {
126126
return false;
127127
};
128128
return ListenerResult::Stop;
129-
});
130-
new EventListener<EventFilter<devtools::PropertyFnEvent<ccColor4B>>>(+[](devtools::PropertyFnEvent<ccColor4B>* event) {
131-
event->fn = +[](const char* name, ccColor4B& prop) {
129+
}).leak();
130+
devtools::PropertyFnEvent<ccColor4B>().listen([](devtools::PropertyFnEvent<ccColor4B>::Fn*& fnPtr) {
131+
fnPtr = +[](const char* name, ccColor4B& prop) {
132132
auto color = ImVec4(
133133
prop.r / 255.f,
134134
prop.g / 255.f,
@@ -145,48 +145,48 @@ void devtools::inputMultiline(const char* label, std::string& str) {
145145
return false;
146146
};
147147
return ListenerResult::Stop;
148-
});
149-
new EventListener<EventFilter<devtools::PropertyFnEvent<ccColor4F>>>(+[](devtools::PropertyFnEvent<ccColor4F>* event) {
150-
event->fn = +[](const char* name, ccColor4F& prop) {
148+
}).leak();
149+
devtools::PropertyFnEvent<ccColor4F>().listen([](devtools::PropertyFnEvent<ccColor4F>::Fn*& fnPtr) {
150+
fnPtr = +[](const char* name, ccColor4F& prop) {
151151
return ImGui::ColorEdit4(name, reinterpret_cast<float*>(&prop));
152152
};
153153
return ListenerResult::Stop;
154-
});
154+
}).leak();
155155

156156
// points/sizes
157-
new EventListener<EventFilter<devtools::PropertyFnEvent<CCPoint>>>(+[](devtools::PropertyFnEvent<CCPoint>* event) {
158-
event->fn = +[](const char* name, CCPoint& prop) {
157+
devtools::PropertyFnEvent<CCPoint>().listen([](devtools::PropertyFnEvent<CCPoint>::Fn*& fnPtr) {
158+
fnPtr = +[](const char* name, CCPoint& prop) {
159159
return ImGui::DragFloat2(name, reinterpret_cast<float*>(&prop));
160160
};
161161
return ListenerResult::Stop;
162-
});
162+
}).leak();
163163

164-
new EventListener<EventFilter<devtools::PropertyFnEvent<CCSize>>>(+[](devtools::PropertyFnEvent<CCSize>* event) {
165-
event->fn = +[](const char* name, CCSize& prop) {
164+
devtools::PropertyFnEvent<CCSize>().listen([](devtools::PropertyFnEvent<CCSize>::Fn*& fnPtr) {
165+
fnPtr = +[](const char* name, CCSize& prop) {
166166
return ImGui::DragFloat2(name, reinterpret_cast<float*>(&prop));
167167
};
168168
return ListenerResult::Stop;
169-
});
170-
new EventListener<EventFilter<devtools::PropertyFnEvent<CCRect>>>(+[](devtools::PropertyFnEvent<CCRect>* event) {
171-
event->fn = +[](const char* name, CCRect& prop) {
169+
}).leak();
170+
devtools::PropertyFnEvent<CCRect>().listen([](devtools::PropertyFnEvent<CCRect>::Fn*& fnPtr) {
171+
fnPtr = +[](const char* name, CCRect& prop) {
172172
return ImGui::DragFloat4(name, reinterpret_cast<float*>(&prop));
173173
};
174174
return ListenerResult::Stop;
175-
});
175+
}).leak();
176176

177177
// label
178-
new EventListener<EventFilter<devtools::DrawLabelFnEvent>>(+[](devtools::DrawLabelFnEvent* event) {
179-
event->fn = +[](const char* text) {
178+
devtools::DrawLabelFnEvent().listen([](devtools::DrawLabelFnEvent::Fn*& fnPtr) {
179+
fnPtr = +[](const char* text) {
180180
ImGui::Text("%s", text);
181181
};
182182
return ListenerResult::Stop;
183-
});
183+
}).leak();
184184

185185
// button
186-
new EventListener<EventFilter<devtools::ButtonFnEvent>>(+[](devtools::ButtonFnEvent* event) {
187-
event->fn = +[](const char* label) {
186+
devtools::ButtonFnEvent().listen([](devtools::ButtonFnEvent::Fn*& fnPtr) {
187+
fnPtr = +[](const char* label) {
188188
return ImGui::Button(label);
189189
};
190190
return ListenerResult::Stop;
191-
});
191+
}).leak();
192192
}

‎src/DevTools.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -111,8 +111,8 @@ void DevTools::setDraggedNode(CCNode* node) {
111111
m_draggedNode = node;
112112
}
113113

114-
void DevTools::addCustomCallback(std::function<void(CCNode*)> callback) {
115-
m_customCallbacks.push_back(std::move(callback));
114+
void DevTools::addCustomCallback(Function<void(CCNode*)>&& callback) {
115+
m_customCallbacks.push_back(std::forward<Function<void(CCNode*)>>(callback));
116116
}
117117

118118
DragButton* DevTools::getDragButton() {

‎src/DevTools.hpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,7 @@ class DevTools {
5656
Ref<CCNode> m_selectedNode;
5757
Ref<CCNode> m_draggedNode;
5858
std::vector<std::pair<CCNode*, HighlightMode>> m_toHighlight;
59-
std::vector<std::function<void(CCNode*)>> m_customCallbacks;
59+
std::vector<Function<void(CCNode*)>> m_customCallbacks;
6060
std::string m_searchQuery;
6161
std::string m_prevQuery;
6262
std::unordered_map<CCNode*, bool> m_nodeOpen;
@@ -121,7 +121,7 @@ class DevTools {
121121
CCNode* getDraggedNode() const;
122122
void setDraggedNode(CCNode* node);
123123

124-
void addCustomCallback(std::function<void(CCNode*)> callback);
124+
void addCustomCallback(Function<void(CCNode*)>&& callback);
125125

126126
DragButton* getDragButton();
127127
void setupDragButton();

‎src/main.cpp‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -35,9 +35,9 @@ class $modify(CCKeyboardDispatcher) {
3535

3636
#include <Geode/loader/GameEvent.hpp>
3737
$execute {
38-
new EventListener<GameEventFilter>(+[](GameEvent*) {
38+
GameEvent(GameEventType::Loaded).listen([] {
3939
if (DevTools::get()->isButtonEnabled()) DevTools::get()->setupDragButton();
40-
}, GameEventFilter(GameEventType::Loaded));
40+
}).leak();
4141
}
4242

4343
#include <Geode/modify/CCScene.hpp>
@@ -153,13 +153,13 @@ class $modify(CCEGLView) {
153153
};
154154

155155
// For the one eclipse shortcut
156-
struct ToggleDevToolsEvent : geode::Event {
157-
ToggleDevToolsEvent() {}
156+
struct ToggleDevToolsEvent : SimpleEvent<ToggleDevToolsEvent> {
157+
using SimpleEvent::SimpleEvent;
158158
};
159159

160-
$on_mod(Loaded) {
161-
new EventListener<EventFilter<ToggleDevToolsEvent>>(+[](ToggleDevToolsEvent* e) {
160+
$execute {
161+
ToggleDevToolsEvent().listen([] {
162162
DevTools::get()->toggle();
163163
return ListenerResult::Stop;
164-
});
164+
}).leak();
165165
}

‎src/nodes/DragButton.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@
66

77
using namespace geode::prelude;
88

9-
bool DragButton::init(CCNode* node, std::function<void()> onPress) {
9+
bool DragButton::init(CCNode* node, Function<void()> onPress) {
1010
if (!CCLayer::init()) return false;
1111
this->setTouchEnabled(true);
1212
this->setAnchorPoint({.5f, .5f});
@@ -58,7 +58,7 @@ void DragButton::registerWithTouchDispatcher() {
5858
CCTouchDispatcher::get()->addTargetedDelegate(this, -512, true);
5959
}
6060

61-
DragButton* DragButton::create(CCNode* node, std::function<void ()> onPress) {
61+
DragButton* DragButton::create(CCNode* node, geode::Function<void ()> onPress) {
6262
auto ret = new DragButton;
6363
if (ret->init(node, std::move(onPress))) {
6464
ret->autorelease();

0 commit comments

Comments
 (0)