blob: 4df498944b0cc2b0f9e8b56e624e6058e48aee66 [file] [log] [blame]
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_BASE_CLASS_PROPERTY_H_
#define UI_BASE_CLASS_PROPERTY_H_
#include <stdint.h>
#include <map>
#include <memory>
#include <set>
#include "ui/base/property_data.h"
#include "ui/base/ui_base_export.h"
#include "ui/base/ui_base_types.h"
// This header should be included by code that defines ClassProperties.
//
// To define a new ClassProperty:
//
// #include "foo/foo_export.h"
// #include "ui/base/class_property.h"
//
// DECLARE_EXPORTED_UI_CLASS_PROPERTY_TYPE(FOO_EXPORT, MyType);
// namespace foo {
// // Use this to define an exported property that is primitive,
// // or a pointer you don't want automatically deleted.
// DEFINE_UI_CLASS_PROPERTY_KEY(MyType, kMyKey, MyDefault);
//
// // Use this to define an exported property whose value is a heap
// // allocated object, and has to be owned and freed by the class.
// DEFINE_OWNED_UI_CLASS_PROPERTY_KEY(gfx::Rect, kRestoreBoundsKey, nullptr);
//
// // Use this to define a non exported property that is primitive,
// // or a pointer you don't want to automatically deleted, and is used
// // only in a specific file. This will define the property in an unnamed
// // namespace which cannot be accessed from another file.
// DEFINE_LOCAL_UI_CLASS_PROPERTY_KEY(MyType, kMyKey, MyDefault);
//
// } // foo namespace
//
// To define a new type used for ClassProperty.
//
// // outside all namespaces:
// DECLARE_EXPORTED_UI_CLASS_PROPERTY_TYPE(FOO_EXPORT, MyType)
//
// If a property type is not exported, use DECLARE_CLASS_PROPERTY_TYPE(MyType)
// which is a shorthand for DECLARE_EXPORTED_CLASS_PROPERTY_TYPE(, MyType).
namespace ui {
// Type of a function to delete a property that this window owns.
using PropertyDeallocator = void(*)(int64_t value);
template<typename T>
struct ClassProperty {
T default_value;
const char* name;
PropertyDeallocator deallocator;
};
namespace subtle {
class PropertyHelper;
}
class UI_BASE_EXPORT PropertyHandler {
public:
PropertyHandler();
~PropertyHandler();
// Sets the |value| of the given class |property|. Setting to the default
// value (e.g., NULL) removes the property. The caller is responsible for the
// lifetime of any object set as a property on the class.
template<typename T>
void SetProperty(const ClassProperty<T>* property, T value);
// Returns the value of the given class |property|. Returns the
// property-specific default value if the property was not previously set.
template<typename T>
T GetProperty(const ClassProperty<T>* property) const;
// Sets the |property| to its default value. Useful for avoiding a cast when
// setting to NULL.
template<typename T>
void ClearProperty(const ClassProperty<T>* property);
// Returns the value of all properties with a non-default value.
std::set<const void*> GetAllPropertyKeys() const;
protected:
friend class subtle::PropertyHelper;
virtual void AfterPropertyChange(const void* key,
int64_t old_value,
std::unique_ptr<PropertyData> data) {}
virtual std::unique_ptr<PropertyData> BeforePropertyChange(const void* key);
void ClearProperties();
// Called by the public {Set,Get,Clear}Property functions.
int64_t SetPropertyInternal(const void* key,
const char* name,
PropertyDeallocator deallocator,
int64_t value,
int64_t default_value);
int64_t GetPropertyInternal(const void* key, int64_t default_value) const;
private:
// Value struct to keep the name and deallocator for this property.
// Key cannot be used for this purpose because it can be char* or
// ClassProperty<>.
struct Value {
const char* name;
int64_t value;
PropertyDeallocator deallocator;
};
std::map<const void*, Value> prop_map_;
};
namespace {
// No single new-style cast works for every conversion to/from int64_t, so we
// need this helper class. A third specialization is needed for bool because
// MSVC warning C4800 (forcing value to bool) is not suppressed by an explicit
// cast (!).
template<typename T>
class ClassPropertyCaster {
public:
static int64_t ToInt64(T x) { return static_cast<int64_t>(x); }
static T FromInt64(int64_t x) { return static_cast<T>(x); }
};
template<typename T>
class ClassPropertyCaster<T*> {
public:
static int64_t ToInt64(T* x) { return reinterpret_cast<int64_t>(x); }
static T* FromInt64(int64_t x) { return reinterpret_cast<T*>(x); }
};
template<>
class ClassPropertyCaster<bool> {
public:
static int64_t ToInt64(bool x) { return static_cast<int64_t>(x); }
static bool FromInt64(int64_t x) { return x != 0; }
};
} // namespace
namespace subtle {
class UI_BASE_EXPORT PropertyHelper {
public:
template<typename T>
static void Set(::ui::PropertyHandler* handler,
const ::ui::ClassProperty<T>* property, T value) {
int64_t old = handler->SetPropertyInternal(
property, property->name,
value == property->default_value ? nullptr : property->deallocator,
ClassPropertyCaster<T>::ToInt64(value),
ClassPropertyCaster<T>::ToInt64(property->default_value));
if (property->deallocator &&
old != ClassPropertyCaster<T>::ToInt64(property->default_value)) {
(*property->deallocator)(old);
}
}
template<typename T>
static T Get(const ::ui::PropertyHandler* handler,
const ::ui::ClassProperty<T>* property) {
return ClassPropertyCaster<T>::FromInt64(handler->GetPropertyInternal(
property, ClassPropertyCaster<T>::ToInt64(property->default_value)));
}
template<typename T>
static void Clear(::ui::PropertyHandler* handler,
const ::ui::ClassProperty<T>* property) {
handler->SetProperty(property, property->default_value);
}
};
} // namespace subtle
} // namespace ui
// Macros to instantiate the property getter/setter template functions.
#define DECLARE_EXPORTED_UI_CLASS_PROPERTY_TYPE(EXPORT, T) \
namespace ui { \
template <> \
EXPORT void PropertyHandler::SetProperty( \
const ClassProperty<T>* property, T value) { \
subtle::PropertyHelper::Set<T>(this, property, value); \
} \
template <> \
EXPORT T PropertyHandler::GetProperty( \
const ClassProperty<T>* property) const { \
return subtle::PropertyHelper::Get<T>(this, property); \
} \
template <> \
EXPORT void PropertyHandler::ClearProperty( \
const ClassProperty<T>* property) { \
subtle::PropertyHelper::Clear<T>(this, property); \
} \
}
#define DECLARE_UI_CLASS_PROPERTY_TYPE(T) \
DECLARE_EXPORTED_UI_CLASS_PROPERTY_TYPE(, T)
#define DEFINE_UI_CLASS_PROPERTY_KEY(TYPE, NAME, DEFAULT) \
static_assert(sizeof(TYPE) <= sizeof(int64_t), "property type too large"); \
namespace { \
const ::ui::ClassProperty<TYPE> NAME##_Value = {DEFAULT, #NAME, nullptr}; \
} \
const ::ui::ClassProperty<TYPE>* const NAME = &NAME##_Value;
#define DEFINE_LOCAL_UI_CLASS_PROPERTY_KEY(TYPE, NAME, DEFAULT) \
static_assert(sizeof(TYPE) <= sizeof(int64_t), "property type too large"); \
namespace { \
const ::ui::ClassProperty<TYPE> NAME##_Value = {DEFAULT, #NAME, nullptr}; \
const ::ui::ClassProperty<TYPE>* const NAME = &NAME##_Value; \
}
#define DEFINE_OWNED_UI_CLASS_PROPERTY_KEY(TYPE, NAME, DEFAULT) \
namespace { \
void Deallocator##NAME(int64_t p) { \
enum { type_must_be_complete = sizeof(TYPE) }; \
delete ::ui::ClassPropertyCaster<TYPE*>::FromInt64(p); \
} \
const ::ui::ClassProperty<TYPE*> NAME##_Value = {DEFAULT, #NAME, \
&Deallocator##NAME}; \
} \
const ::ui::ClassProperty<TYPE*>* const NAME = &NAME##_Value;
#endif // UI_BASE_CLASS_PROPERTY_H_