source/modules/juce_core/native/juce_mac_ObjCHelpers.h

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library.
   5    Copyright (c) 2022 - Raw Material Software Limited
   6
   7    JUCE is an open source library subject to commercial or open-source
   8    licensing.
   9
  10    The code included in this file is provided under the terms of the ISC license
  11    http://www.isc.org/downloads/software-support-policy/isc-license. Permission
  12    To use, copy, modify, and/or distribute this software for any purpose with or
  13    without fee is hereby granted provided that the above copyright notice and
  14    this permission notice appear in all copies.
  15
  16    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
  17    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
  18    DISCLAIMED.
  19
  20   ==============================================================================
  21 */
  22
  23 #include "juce_mac_CFHelpers.h"
  24
  25 /* This file contains a few helper functions that are used internally but which
  26    need to be kept away from the public headers because they use obj-C symbols.
  27 */
  28 namespace juce
  29 {
  30
  31 //==============================================================================
  32 inline Range<int> nsRangeToJuce (NSRange range)
  33 {
  34     return { (int) range.location, (int) (range.location + range.length) };
  35 }
  36
  37 inline NSRange juceRangeToNS (Range<int> range)
  38 {
  39     return NSMakeRange ((NSUInteger) range.getStart(), (NSUInteger) range.getLength());
  40 }
  41
  42 inline String nsStringToJuce (NSString* s)
  43 {
  44     return CharPointer_UTF8 ([s UTF8String]);
  45 }
  46
  47 inline NSString* juceStringToNS (const String& s)
  48 {
  49     return [NSString stringWithUTF8String: s.toUTF8()];
  50 }
  51
  52 inline NSString* nsStringLiteral (const char* const s) noexcept
  53 {
  54     return [NSString stringWithUTF8String: s];
  55 }
  56
  57 inline NSString* nsEmptyString() noexcept
  58 {
  59     return [NSString string];
  60 }
  61
  62 inline NSURL* createNSURLFromFile (const String& f)
  63 {
  64     return [NSURL fileURLWithPath: juceStringToNS (f)];
  65 }
  66
  67 inline NSURL* createNSURLFromFile (const File& f)
  68 {
  69     return createNSURLFromFile (f.getFullPathName());
  70 }
  71
  72 inline NSArray* createNSArrayFromStringArray (const StringArray& strings)
  73 {
  74     auto array = [[NSMutableArray alloc] init];
  75
  76     for (auto string: strings)
  77         [array addObject:juceStringToNS (string)];
  78
  79     return [array autorelease];
  80 }
  81
  82 inline NSArray* varArrayToNSArray (const var& varToParse);
  83
  84 inline NSDictionary* varObjectToNSDictionary (const var& varToParse)
  85 {
  86     auto dictionary = [NSMutableDictionary dictionary];
  87
  88     if (varToParse.isObject())
  89     {
  90         auto* dynamicObject = varToParse.getDynamicObject();
  91
  92         auto& properties = dynamicObject->getProperties();
  93
  94         for (int i = 0; i < properties.size(); ++i)
  95         {
  96             auto* keyString = juceStringToNS (properties.getName (i).toString());
  97
  98             const var& valueVar = properties.getValueAt (i);
  99
 100             if (valueVar.isObject())
 101             {
 102                 auto* valueDictionary = varObjectToNSDictionary (valueVar);
 103
 104                 [dictionary setObject: valueDictionary forKey: keyString];
 105             }
 106             else if (valueVar.isArray())
 107             {
 108                 auto* valueArray = varArrayToNSArray (valueVar);
 109
 110                 [dictionary setObject: valueArray forKey: keyString];
 111             }
 112             else
 113             {
 114                 auto* valueString = juceStringToNS (valueVar.toString());
 115
 116                 [dictionary setObject: valueString forKey: keyString];
 117             }
 118         }
 119     }
 120
 121     return dictionary;
 122 }
 123
 124 inline NSArray* varArrayToNSArray (const var& varToParse)
 125 {
 126     jassert (varToParse.isArray());
 127
 128     if (! varToParse.isArray())
 129         return nil;
 130
 131     const auto* varArray = varToParse.getArray();
 132
 133     auto array = [NSMutableArray arrayWithCapacity: (NSUInteger) varArray->size()];
 134
 135     for (const auto& aVar : *varArray)
 136     {
 137         if (aVar.isObject())
 138         {
 139             auto* valueDictionary = varObjectToNSDictionary (aVar);
 140
 141             [array addObject: valueDictionary];
 142         }
 143         else if (aVar.isArray())
 144         {
 145             auto* valueArray = varArrayToNSArray (aVar);
 146
 147             [array addObject: valueArray];
 148         }
 149         else
 150         {
 151             auto* valueString = juceStringToNS (aVar.toString());
 152
 153             [array addObject: valueString];
 154         }
 155     }
 156
 157     return array;
 158 }
 159
 160 var nsObjectToVar (NSObject* array);
 161
 162 inline var nsDictionaryToVar (NSDictionary* dictionary)
 163 {
 164     DynamicObject::Ptr dynamicObject (new DynamicObject());
 165
 166     for (NSString* key in dictionary)
 167         dynamicObject->setProperty (nsStringToJuce (key), nsObjectToVar ([dictionary objectForKey: key]));
 168
 169     return var (dynamicObject.get());
 170 }
 171
 172 inline var nsArrayToVar (NSArray* array)
 173 {
 174     Array<var> resultArray;
 175
 176     for (id value in array)
 177         resultArray.add (nsObjectToVar (value));
 178
 179     return var (resultArray);
 180 }
 181
 182 inline var nsObjectToVar (NSObject* obj)
 183 {
 184     if ([obj isKindOfClass: [NSString class]])          return nsStringToJuce ((NSString*) obj);
 185     else if ([obj isKindOfClass: [NSNumber class]])     return nsStringToJuce ([(NSNumber*) obj stringValue]);
 186     else if ([obj isKindOfClass: [NSDictionary class]]) return nsDictionaryToVar ((NSDictionary*) obj);
 187     else if ([obj isKindOfClass: [NSArray class]])      return nsArrayToVar ((NSArray*) obj);
 188     else
 189     {
 190         // Unsupported yet, add here!
 191         jassertfalse;
 192     }
 193
 194     return {};
 195 }
 196
 197 #if JUCE_MAC
 198 template <typename RectangleType>
 199 NSRect makeNSRect (const RectangleType& r) noexcept
 200 {
 201     return NSMakeRect (static_cast<CGFloat> (r.getX()),
 202                        static_cast<CGFloat> (r.getY()),
 203                        static_cast<CGFloat> (r.getWidth()),
 204                        static_cast<CGFloat> (r.getHeight()));
 205 }
 206 #endif
 207
 208 #if JUCE_INTEL
 209  template <typename T>
 210  struct NeedsStret
 211  {
 212     #if JUCE_32BIT
 213      static constexpr auto value = sizeof (T) > 8;
 214     #else
 215      static constexpr auto value = sizeof (T) > 16;
 216     #endif
 217  };
 218
 219  template <>
 220  struct NeedsStret<void> { static constexpr auto value = false; };
 221
 222  template <typename T, bool b = NeedsStret<T>::value>
 223  struct MetaSuperFn { static constexpr auto value = objc_msgSendSuper_stret; };
 224
 225  template <typename T>
 226  struct MetaSuperFn<T, false> { static constexpr auto value = objc_msgSendSuper; };
 227 #else
 228  template <typename>
 229  struct MetaSuperFn { static constexpr auto value = objc_msgSendSuper; };
 230 #endif
 231
 232 template <typename SuperType, typename ReturnType, typename... Params>
 233 inline ReturnType ObjCMsgSendSuper (id self, SEL sel, Params... params)
 234 {
 235     using SuperFn = ReturnType (*) (struct objc_super*, SEL, Params...);
 236     const auto fn = reinterpret_cast<SuperFn> (MetaSuperFn<ReturnType>::value);
 237
 238     objc_super s = { self, [SuperType class] };
 239     return fn (&s, sel, params...);
 240 }
 241
 242 //==============================================================================
 243 struct NSObjectDeleter
 244 {
 245     void operator() (NSObject* object) const noexcept
 246     {
 247         if (object != nullptr)
 248             [object release];
 249     }
 250 };
 251
 252 template <typename NSType>
 253 using NSUniquePtr = std::unique_ptr<NSType, NSObjectDeleter>;
 254
 255 /*  This has very similar semantics to NSUniquePtr, with the main difference that it doesn't
 256     automatically add a pointer to the managed type. This makes it possible to declare
 257     scoped handles to id or block types.
 258 */
 259 template <typename T>
 260 class ObjCObjectHandle
 261 {
 262 public:
 263     ObjCObjectHandle() = default;
 264
 265     // Note that this does *not* retain the argument.
 266     explicit ObjCObjectHandle (T ptr) : item (ptr) {}
 267
 268     ~ObjCObjectHandle() noexcept { reset(); }
 269
 270     ObjCObjectHandle (const ObjCObjectHandle& other)
 271         : item (other.item)
 272     {
 273         if (item != nullptr)
 274             [item retain];
 275     }
 276
 277     ObjCObjectHandle& operator= (const ObjCObjectHandle& other)
 278     {
 279         auto copy = other;
 280         swap (copy);
 281         return *this;
 282     }
 283
 284     ObjCObjectHandle (ObjCObjectHandle&& other) noexcept { swap (other); }
 285
 286     ObjCObjectHandle& operator= (ObjCObjectHandle&& other) noexcept
 287     {
 288         reset();
 289         swap (other);
 290         return *this;
 291     }
 292
 293     // Note that this does *not* retain the argument.
 294     void reset (T ptr) { *this = ObjCObjectHandle { ptr }; }
 295
 296     T get() const { return item; }
 297
 298     void reset()
 299     {
 300         if (item != nullptr)
 301             [item release];
 302
 303         item = {};
 304     }
 305
 306     bool operator== (const ObjCObjectHandle& other) const { return item == other.item; }
 307     bool operator!= (const ObjCObjectHandle& other) const { return ! (*this == other); }
 308
 309     bool operator== (std::nullptr_t) const { return item == nullptr; }
 310     bool operator!= (std::nullptr_t) const { return ! (*this == nullptr); }
 311
 312 private:
 313     void swap (ObjCObjectHandle& other) noexcept { std::swap (other.item, item); }
 314
 315     T item{};
 316 };
 317
 318 //==============================================================================
 319 namespace detail
 320 {
 321     constexpr auto makeCompileTimeStr()
 322     {
 323         return std::array<char, 1> { { '\0' } };
 324     }
 325
 326     template <typename A, size_t... As, typename B, size_t... Bs>
 327     constexpr auto joinCompileTimeStrImpl (A&& a, std::index_sequence<As...>,
 328                                            B&& b, std::index_sequence<Bs...>)
 329     {
 330         return std::array<char, sizeof... (As) + sizeof... (Bs) + 1> { { a[As]..., b[Bs]..., '\0' } };
 331     }
 332
 333     template <size_t A, size_t B>
 334     constexpr auto joinCompileTimeStr (const char (&a)[A], std::array<char, B> b)
 335     {
 336         return joinCompileTimeStrImpl (a, std::make_index_sequence<A - 1>(),
 337                                        b, std::make_index_sequence<B - 1>());
 338     }
 339
 340     template <size_t A, typename... Others>
 341     constexpr auto makeCompileTimeStr (const char (&v)[A], Others&&... others)
 342     {
 343         return joinCompileTimeStr (v, makeCompileTimeStr (others...));
 344     }
 345 } // namespace detail
 346
 347 //==============================================================================
 348 template <typename Type>
 349 inline Type getIvar (id self, const char* name)
 350 {
 351     void* v = nullptr;
 352     object_getInstanceVariable (self, name, &v);
 353     return static_cast<Type> (v);
 354 }
 355
 356 template <typename SuperclassType>
 357 struct ObjCClass
 358 {
 359     ObjCClass (const char* nameRoot)
 360         : cls (objc_allocateClassPair ([SuperclassType class], getRandomisedName (nameRoot).toUTF8(), 0))
 361     {
 362     }
 363
 364     ~ObjCClass()
 365     {
 366         auto kvoSubclassName = String ("NSKVONotifying_") + class_getName (cls);
 367
 368         if (objc_getClass (kvoSubclassName.toUTF8()) == nullptr)
 369             objc_disposeClassPair (cls);
 370     }
 371
 372     void registerClass()
 373     {
 374         objc_registerClassPair (cls);
 375     }
 376
 377     SuperclassType* createInstance() const
 378     {
 379         return class_createInstance (cls, 0);
 380     }
 381
 382     template <typename Type>
 383     void addIvar (const char* name)
 384     {
 385         BOOL b = class_addIvar (cls, name, sizeof (Type), (uint8_t) rint (log2 (sizeof (Type))), @encode (Type));
 386         jassert (b); ignoreUnused (b);
 387     }
 388
 389     template <typename Result, typename... Args>
 390     void addMethod (SEL selector, Result (*callbackFn) (id, SEL, Args...))
 391     {
 392         const auto s = detail::makeCompileTimeStr (@encode (Result), @encode (id), @encode (SEL), @encode (Args)...);
 393         const auto b = class_addMethod (cls, selector, (IMP) callbackFn, s.data());
 394         jassertquiet (b);
 395     }
 396
 397     void addProtocol (Protocol* protocol)
 398     {
 399         BOOL b = class_addProtocol (cls, protocol);
 400         jassert (b); ignoreUnused (b);
 401     }
 402
 403     template <typename ReturnType, typename... Params>
 404     static ReturnType sendSuperclassMessage (id self, SEL sel, Params... params)
 405     {
 406         return ObjCMsgSendSuper<SuperclassType, ReturnType, Params...> (self, sel, params...);
 407     }
 408
 409     Class cls;
 410
 411 private:
 412     static String getRandomisedName (const char* root)
 413     {
 414         return root + String::toHexString (juce::Random::getSystemRandom().nextInt64());
 415     }
 416
 417     JUCE_DECLARE_NON_COPYABLE (ObjCClass)
 418 };
 419
 420 //==============================================================================
 421 #ifndef DOXYGEN
 422 template <class JuceClass>
 423 struct ObjCLifetimeManagedClass : public ObjCClass<NSObject>
 424 {
 425     ObjCLifetimeManagedClass()
 426         : ObjCClass<NSObject> ("ObjCLifetimeManagedClass_")
 427     {
 428         addIvar<JuceClass*> ("cppObject");
 429
 430         JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wundeclared-selector")
 431         addMethod (@selector (initWithJuceObject:), initWithJuceObject);
 432         JUCE_END_IGNORE_WARNINGS_GCC_LIKE
 433
 434         addMethod (@selector (dealloc),             dealloc);
 435
 436         registerClass();
 437     }
 438
 439     static id initWithJuceObject (id _self, SEL, JuceClass* obj)
 440     {
 441         NSObject* self = sendSuperclassMessage<NSObject*> (_self, @selector (init));
 442         object_setInstanceVariable (self, "cppObject", obj);
 443
 444         return self;
 445     }
 446
 447     static void dealloc (id _self, SEL)
 448     {
 449         if (auto* obj = getIvar<JuceClass*> (_self, "cppObject"))
 450         {
 451             delete obj;
 452             object_setInstanceVariable (_self, "cppObject", nullptr);
 453         }
 454
 455         sendSuperclassMessage<void> (_self, @selector (dealloc));
 456     }
 457
 458     static ObjCLifetimeManagedClass objCLifetimeManagedClass;
 459 };
 460
 461 template <typename Class>
 462 ObjCLifetimeManagedClass<Class> ObjCLifetimeManagedClass<Class>::objCLifetimeManagedClass;
 463 #endif
 464
 465 // this will return an NSObject which takes ownership of the JUCE instance passed-in
 466 // This is useful to tie the life-time of a juce instance to the life-time of an NSObject
 467 template <typename Class>
 468 NSObject* createNSObjectFromJuceClass (Class* obj)
 469 {
 470     JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wobjc-method-access")
 471     return [ObjCLifetimeManagedClass<Class>::objCLifetimeManagedClass.createInstance() initWithJuceObject:obj];
 472     JUCE_END_IGNORE_WARNINGS_GCC_LIKE
 473 }
 474
 475 // Get the JUCE class instance that was tied to the life-time of an NSObject with the
 476 // function above
 477 template <typename Class>
 478 Class* getJuceClassFromNSObject (NSObject* obj)
 479 {
 480     return obj != nullptr ? getIvar<Class*> (obj, "cppObject") : nullptr;
 481 }
 482
 483 template <typename ReturnT, class Class, typename... Params>
 484 ReturnT (^CreateObjCBlock(Class* object, ReturnT (Class::*fn)(Params...))) (Params...)
 485 {
 486     __block Class* _this = object;
 487     __block ReturnT (Class::*_fn)(Params...) = fn;
 488
 489     return [[^ReturnT (Params... params) { return (_this->*_fn) (params...); } copy] autorelease];
 490 }
 491
 492 template <typename BlockType>
 493 class ObjCBlock
 494 {
 495 public:
 496     ObjCBlock()  { block = nullptr; }
 497     template <typename R, class C, typename... P>
 498     ObjCBlock (C* _this, R (C::*fn)(P...))  : block (CreateObjCBlock (_this, fn)) {}
 499     ObjCBlock (BlockType b) : block ([b copy]) {}
 500     ObjCBlock& operator= (const BlockType& other) { if (block != nullptr) { [block release]; } block = [other copy]; return *this; }
 501     bool operator== (const void* ptr) const  { return ((const void*) block == ptr); }
 502     bool operator!= (const void* ptr) const  { return ((const void*) block != ptr); }
 503     ~ObjCBlock() { if (block != nullptr) [block release]; }
 504
 505     operator BlockType() const { return block; }
 506
 507 private:
 508     BlockType block;
 509 };
 510
 511 } // namespace juce