2020-01-18 08:38:21 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright notice, this
|
|
|
|
* list of conditions and the following disclaimer.
|
|
|
|
*
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
|
|
* and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2019-01-20 03:49:48 +00:00
|
|
|
#pragma once
|
|
|
|
|
2020-02-14 21:29:06 +00:00
|
|
|
#include <AK/Forward.h>
|
2020-09-15 19:33:37 +00:00
|
|
|
#include <AK/HashMap.h>
|
2019-08-17 09:26:19 +00:00
|
|
|
#include <AK/IntrusiveList.h>
|
2019-09-21 22:17:53 +00:00
|
|
|
#include <AK/Noncopyable.h>
|
|
|
|
#include <AK/NonnullRefPtrVector.h>
|
2019-09-21 08:13:34 +00:00
|
|
|
#include <AK/String.h>
|
2020-07-26 15:16:35 +00:00
|
|
|
#include <AK/TypeCasts.h>
|
2019-01-20 03:49:48 +00:00
|
|
|
#include <AK/Weakable.h>
|
2020-02-14 21:29:06 +00:00
|
|
|
#include <LibCore/Forward.h>
|
2020-09-15 19:33:37 +00:00
|
|
|
#include <LibCore/Property.h>
|
2019-08-18 18:36:37 +00:00
|
|
|
|
2020-02-02 11:34:39 +00:00
|
|
|
namespace Core {
|
|
|
|
|
2020-03-05 13:40:47 +00:00
|
|
|
class RPCClient;
|
|
|
|
|
2019-12-29 14:58:07 +00:00
|
|
|
enum class TimerShouldFireWhenNotVisible {
|
|
|
|
No = 0,
|
|
|
|
Yes
|
|
|
|
};
|
|
|
|
|
2019-09-21 08:13:34 +00:00
|
|
|
#define C_OBJECT(klass) \
|
|
|
|
public: \
|
|
|
|
virtual const char* class_name() const override { return #klass; } \
|
|
|
|
template<class... Args> \
|
2019-09-21 22:17:53 +00:00
|
|
|
static inline NonnullRefPtr<klass> construct(Args&&... args) \
|
2019-09-21 08:13:34 +00:00
|
|
|
{ \
|
2019-09-21 22:17:53 +00:00
|
|
|
return adopt(*new klass(forward<Args>(args)...)); \
|
2019-09-21 08:13:34 +00:00
|
|
|
}
|
2019-12-29 14:58:07 +00:00
|
|
|
|
|
|
|
#define C_OBJECT_ABSTRACT(klass) \
|
|
|
|
public: \
|
|
|
|
virtual const char* class_name() const override { return #klass; }
|
2019-07-25 17:49:28 +00:00
|
|
|
|
2020-02-02 11:34:39 +00:00
|
|
|
class Object
|
|
|
|
: public RefCounted<Object>
|
|
|
|
, public Weakable<Object> {
|
|
|
|
// NOTE: No C_OBJECT macro for Core::Object itself.
|
2019-09-21 22:17:53 +00:00
|
|
|
|
2020-08-26 19:52:24 +00:00
|
|
|
AK_MAKE_NONCOPYABLE(Object);
|
|
|
|
AK_MAKE_NONMOVABLE(Object);
|
|
|
|
|
2019-08-17 09:26:19 +00:00
|
|
|
IntrusiveListNode m_all_objects_list_node;
|
|
|
|
|
2020-10-16 20:04:19 +00:00
|
|
|
public:
|
2020-02-02 11:34:39 +00:00
|
|
|
virtual ~Object();
|
2019-01-20 03:49:48 +00:00
|
|
|
|
2019-07-25 17:49:28 +00:00
|
|
|
virtual const char* class_name() const = 0;
|
2020-02-02 11:34:39 +00:00
|
|
|
virtual void event(Core::Event&);
|
2019-01-20 03:49:48 +00:00
|
|
|
|
2019-07-10 18:33:53 +00:00
|
|
|
const String& name() const { return m_name; }
|
|
|
|
void set_name(const StringView& name) { m_name = name; }
|
|
|
|
|
2020-02-02 11:34:39 +00:00
|
|
|
NonnullRefPtrVector<Object>& children() { return m_children; }
|
|
|
|
const NonnullRefPtrVector<Object>& children() const { return m_children; }
|
2019-01-20 03:49:48 +00:00
|
|
|
|
2019-05-27 01:52:19 +00:00
|
|
|
template<typename Callback>
|
|
|
|
void for_each_child(Callback callback)
|
|
|
|
{
|
2019-09-21 22:17:53 +00:00
|
|
|
for (auto& child : m_children) {
|
|
|
|
if (callback(child) == IterationDecision::Break)
|
2019-05-27 01:52:19 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-28 09:53:16 +00:00
|
|
|
template<typename T, typename Callback>
|
|
|
|
void for_each_child_of_type(Callback callback);
|
2019-05-27 02:18:24 +00:00
|
|
|
|
2020-02-02 11:34:39 +00:00
|
|
|
bool is_ancestor_of(const Object&) const;
|
2019-09-20 18:37:31 +00:00
|
|
|
|
2020-02-02 11:34:39 +00:00
|
|
|
Object* parent() { return m_parent; }
|
|
|
|
const Object* parent() const { return m_parent; }
|
2019-01-20 03:49:48 +00:00
|
|
|
|
2019-12-29 14:58:07 +00:00
|
|
|
void start_timer(int ms, TimerShouldFireWhenNotVisible = TimerShouldFireWhenNotVisible::No);
|
2019-01-31 16:31:23 +00:00
|
|
|
void stop_timer();
|
|
|
|
bool has_timer() const { return m_timer_id; }
|
2019-01-20 03:49:48 +00:00
|
|
|
|
2020-02-02 11:34:39 +00:00
|
|
|
void add_child(Object&);
|
|
|
|
void insert_child_before(Object& new_child, Object& before_child);
|
|
|
|
void remove_child(Object&);
|
2019-01-20 03:49:48 +00:00
|
|
|
|
2019-03-18 23:01:02 +00:00
|
|
|
void dump_tree(int indent = 0);
|
|
|
|
|
2020-02-02 11:34:39 +00:00
|
|
|
void deferred_invoke(Function<void(Object&)>);
|
2019-04-07 12:36:10 +00:00
|
|
|
|
2019-04-18 20:57:24 +00:00
|
|
|
bool is_widget() const { return m_widget; }
|
2020-02-02 00:57:57 +00:00
|
|
|
virtual bool is_action() const { return false; }
|
2019-03-19 01:20:00 +00:00
|
|
|
virtual bool is_window() const { return false; }
|
2019-03-15 15:12:06 +00:00
|
|
|
|
2020-09-15 19:33:37 +00:00
|
|
|
void save_to(AK::JsonObject&);
|
|
|
|
|
|
|
|
bool set_property(const StringView& name, const JsonValue& value);
|
|
|
|
JsonValue property(const StringView& name);
|
2019-08-18 18:36:37 +00:00
|
|
|
|
2020-02-02 11:34:39 +00:00
|
|
|
static IntrusiveList<Object, &Object::m_all_objects_list_node>& all_objects();
|
2019-08-17 09:26:19 +00:00
|
|
|
|
2020-02-02 11:34:39 +00:00
|
|
|
void dispatch_event(Core::Event&, Object* stay_within = nullptr);
|
2019-09-20 18:37:31 +00:00
|
|
|
|
2019-09-21 22:41:01 +00:00
|
|
|
void remove_from_parent()
|
|
|
|
{
|
|
|
|
if (m_parent)
|
|
|
|
m_parent->remove_child(*this);
|
|
|
|
}
|
|
|
|
|
2020-02-23 06:13:09 +00:00
|
|
|
template<class T, class... Args>
|
2020-03-04 18:07:55 +00:00
|
|
|
inline T& add(Args&&... args)
|
2020-02-23 06:13:09 +00:00
|
|
|
{
|
2020-03-04 18:07:55 +00:00
|
|
|
auto child = T::construct(forward<Args>(args)...);
|
|
|
|
add_child(*child);
|
|
|
|
return child;
|
2020-02-23 06:13:09 +00:00
|
|
|
}
|
|
|
|
|
2019-12-29 14:58:07 +00:00
|
|
|
virtual bool is_visible_for_timer_purposes() const;
|
|
|
|
|
2020-03-05 13:40:47 +00:00
|
|
|
bool is_being_inspected() const { return m_inspector_count; }
|
|
|
|
|
|
|
|
void increment_inspector_count(Badge<RPCClient>);
|
|
|
|
void decrement_inspector_count(Badge<RPCClient>);
|
|
|
|
|
2019-03-15 15:12:06 +00:00
|
|
|
protected:
|
2020-02-02 11:34:39 +00:00
|
|
|
explicit Object(Object* parent = nullptr, bool is_widget = false);
|
2019-07-25 17:49:28 +00:00
|
|
|
|
2020-09-15 19:33:37 +00:00
|
|
|
void register_property(const String& name, Function<JsonValue()> getter, Function<bool(const JsonValue&)> setter = nullptr);
|
|
|
|
|
2020-02-02 11:34:39 +00:00
|
|
|
virtual void timer_event(TimerEvent&);
|
|
|
|
virtual void custom_event(CustomEvent&);
|
2019-01-20 03:49:48 +00:00
|
|
|
|
2019-07-27 07:31:46 +00:00
|
|
|
// NOTE: You may get child events for children that are not yet fully constructed!
|
2020-02-02 11:34:39 +00:00
|
|
|
virtual void child_event(ChildEvent&);
|
2019-07-27 07:31:46 +00:00
|
|
|
|
2020-07-26 15:16:35 +00:00
|
|
|
virtual void did_begin_inspection() { }
|
|
|
|
virtual void did_end_inspection() { }
|
2020-03-05 13:40:47 +00:00
|
|
|
|
2019-03-15 15:12:06 +00:00
|
|
|
private:
|
2020-02-02 11:34:39 +00:00
|
|
|
Object* m_parent { nullptr };
|
2019-07-10 18:33:53 +00:00
|
|
|
String m_name;
|
2019-01-31 16:31:23 +00:00
|
|
|
int m_timer_id { 0 };
|
2020-03-05 13:40:47 +00:00
|
|
|
unsigned m_inspector_count { 0 };
|
2019-04-18 20:57:24 +00:00
|
|
|
bool m_widget { false };
|
2020-09-15 19:33:37 +00:00
|
|
|
HashMap<String, NonnullOwnPtr<Property>> m_properties;
|
2020-02-02 11:34:39 +00:00
|
|
|
NonnullRefPtrVector<Object> m_children;
|
2019-01-20 03:49:48 +00:00
|
|
|
};
|
2019-05-27 02:06:01 +00:00
|
|
|
|
|
|
|
}
|
2019-05-27 02:18:24 +00:00
|
|
|
|
2020-10-15 19:07:36 +00:00
|
|
|
namespace AK {
|
|
|
|
template<>
|
|
|
|
struct Formatter<Core::Object> : Formatter<StringView> {
|
|
|
|
void format(TypeErasedFormatParams&, FormatBuilder&, const Core::Object&);
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2020-07-26 15:16:35 +00:00
|
|
|
namespace Core {
|
2019-05-27 02:18:24 +00:00
|
|
|
template<typename T, typename Callback>
|
2020-02-02 11:34:39 +00:00
|
|
|
inline void Object::for_each_child_of_type(Callback callback)
|
2019-05-27 02:18:24 +00:00
|
|
|
{
|
2019-05-28 09:53:16 +00:00
|
|
|
for_each_child([&](auto& child) {
|
2019-05-27 02:18:24 +00:00
|
|
|
if (is<T>(child))
|
2020-07-26 15:16:35 +00:00
|
|
|
return callback(downcast<T>(child));
|
2019-05-27 02:18:24 +00:00
|
|
|
return IterationDecision::Continue;
|
|
|
|
});
|
|
|
|
}
|
2019-07-14 08:59:26 +00:00
|
|
|
|
2020-02-14 23:44:02 +00:00
|
|
|
const LogStream& operator<<(const LogStream&, const Object&);
|
2020-02-02 11:34:39 +00:00
|
|
|
|
2020-09-15 19:33:37 +00:00
|
|
|
#define REGISTER_INT_PROPERTY(property_name, getter, setter) \
|
|
|
|
register_property( \
|
|
|
|
property_name, \
|
|
|
|
[this] { return this->getter(); }, \
|
|
|
|
[this](auto& value) { \
|
|
|
|
this->setter(value.template to_number<int>()); \
|
|
|
|
return true; \
|
|
|
|
});
|
|
|
|
|
|
|
|
#define REGISTER_BOOL_PROPERTY(property_name, getter, setter) \
|
|
|
|
register_property( \
|
|
|
|
property_name, \
|
|
|
|
[this] { return this->getter(); }, \
|
|
|
|
[this](auto& value) { \
|
|
|
|
this->setter(value.to_bool()); \
|
|
|
|
return true; \
|
|
|
|
});
|
|
|
|
|
|
|
|
#define REGISTER_STRING_PROPERTY(property_name, getter, setter) \
|
|
|
|
register_property( \
|
|
|
|
property_name, \
|
|
|
|
[this] { return this->getter(); }, \
|
|
|
|
[this](auto& value) { \
|
|
|
|
this->setter(value.to_string()); \
|
|
|
|
return true; \
|
|
|
|
});
|
|
|
|
|
|
|
|
#define REGISTER_READONLY_STRING_PROPERTY(property_name, getter) \
|
|
|
|
register_property( \
|
|
|
|
property_name, \
|
|
|
|
[this] { return this->getter(); }, \
|
|
|
|
nullptr);
|
|
|
|
|
|
|
|
#define REGISTER_RECT_PROPERTY(property_name, getter, setter) \
|
|
|
|
register_property( \
|
|
|
|
property_name, \
|
|
|
|
[this] { \
|
|
|
|
auto rect = this->getter(); \
|
|
|
|
JsonObject rect_object; \
|
|
|
|
rect_object.set("x", rect.x()); \
|
|
|
|
rect_object.set("y", rect.y()); \
|
|
|
|
rect_object.set("width", rect.width()); \
|
|
|
|
rect_object.set("height", rect.height()); \
|
|
|
|
return rect_object; \
|
|
|
|
}, \
|
|
|
|
[this](auto& value) { \
|
|
|
|
if (!value.is_object()) \
|
|
|
|
return false; \
|
|
|
|
Gfx::IntRect rect; \
|
|
|
|
rect.set_x(value.as_object().get("x").to_i32()); \
|
|
|
|
rect.set_y(value.as_object().get("y").to_i32()); \
|
|
|
|
rect.set_width(value.as_object().get("width").to_i32()); \
|
|
|
|
rect.set_height(value.as_object().get("height").to_i32()); \
|
|
|
|
setter(rect); \
|
|
|
|
return true; \
|
|
|
|
});
|
|
|
|
|
|
|
|
#define REGISTER_SIZE_PROPERTY(property_name, getter, setter) \
|
|
|
|
register_property( \
|
|
|
|
property_name, \
|
|
|
|
[this] { \
|
|
|
|
auto size = this->getter(); \
|
|
|
|
JsonObject size_object; \
|
|
|
|
size_object.set("width", size.width()); \
|
|
|
|
size_object.set("height", size.height()); \
|
|
|
|
return size_object; \
|
|
|
|
}, \
|
|
|
|
[this](auto& value) { \
|
|
|
|
if (!value.is_object()) \
|
|
|
|
return false; \
|
|
|
|
Gfx::IntSize size; \
|
|
|
|
size.set_width(value.as_object().get("width").to_i32()); \
|
|
|
|
size.set_height(value.as_object().get("height").to_i32()); \
|
|
|
|
setter(size); \
|
|
|
|
return true; \
|
|
|
|
});
|
|
|
|
|
|
|
|
#define REGISTER_SIZE_POLICY_PROPERTY(property_name, getter, setter) \
|
|
|
|
register_property( \
|
|
|
|
property_name, [this]() -> JsonValue { \
|
|
|
|
auto policy = this->getter(); \
|
|
|
|
if (policy == GUI::SizePolicy::Fill) \
|
|
|
|
return "Fill"; \
|
|
|
|
if (policy == GUI::SizePolicy::Fixed) \
|
|
|
|
return "Fixed"; \
|
|
|
|
return JsonValue(); }, \
|
|
|
|
[this](auto& value) { \
|
|
|
|
if (!value.is_string()) \
|
|
|
|
return false; \
|
|
|
|
if (value.as_string() == "Fill") { \
|
|
|
|
setter(GUI::SizePolicy::Fill); \
|
|
|
|
return true; \
|
|
|
|
} \
|
|
|
|
if (value.as_string() == "Fixed") { \
|
|
|
|
setter(GUI::SizePolicy::Fixed); \
|
|
|
|
return true; \
|
|
|
|
} \
|
|
|
|
return false; \
|
|
|
|
});
|
2020-02-02 11:34:39 +00:00
|
|
|
}
|