Vorrei creare l' @IBInspectableelemento come vedi nell'immagine qui sotto:
la mia idea è di usare qualcosa come enum come tipo per @IBInspectable, ma sembra che non sia il caso, qualche idea su come implementare un elemento come questo?
MODIFICARE:
Sembra che @IBInspectablesupporti solo questi tipi:
IntCGFloatDoubleStringBoolCGPointCGSizeCGRectUIColorUIImagepeccato
Risposte:
Non è possibile (per ora). È possibile utilizzare solo i tipi visualizzati nella sezione Attributi di runtime definiti dall'utente .
Dal documento di Apple :
È possibile collegare l'attributo IBInspectable a qualsiasi proprietà in una dichiarazione di classe, estensione di classe o categoria per qualsiasi tipo supportato dagli attributi di runtime definiti da Interface Builder: booleano, numero intero o in virgola mobile, stringa, stringa localizzata, rettangolo, punto, dimensione , colore, gamma e zero.
Un'altra soluzione a questo problema è modificare il modo in cui una proprietà di enumerazione appare al costruttore di interfacce. Per esempio:
#if TARGET_INTERFACE_BUILDER
@property (nonatomic, assign) IBInspectable NSInteger fontWeight;
#else
@property (nonatomic, assign) FontWeight fontWeight;
#endif
Ciò presuppone un'enumerazione denominata FontWeight. Si basa sul fatto che le enumerazioni ei loro valori interi grezzi possono essere usati in modo intercambiabile in Objective-C. Dopo aver fatto ciò, è possibile specificare un numero intero in Interface builder per la proprietà che non è l'ideale, ma funziona e mantiene una piccola quantità di sicurezza dei tipi quando si utilizza la stessa proprietà a livello di programmazione.
Questa è un'alternativa migliore rispetto alla dichiarazione di una proprietà intera separata perché non è necessario scrivere logica aggiuntiva per gestire una seconda proprietà intera che potrebbe essere utilizzata anche per ottenere la stessa cosa.
Tuttavia, questo non funziona con Swift perché non siamo in grado di eseguire il cast implicito da un numero intero a un enum. Qualsiasi pensiero sulla soluzione che sarebbe apprezzato.
Lo faccio usando un valore NSInteger ispezionabile e sovrascrivo il setter per consentirgli di impostare l'enum. Questo ha la limitazione di non utilizzare un elenco popup e se modifichi i valori di enum, le opzioni dell'interfaccia non si aggiorneranno per corrispondere.
Esempio.
Nel file di intestazione:
typedef NS_ENUM(NSInteger, LabelStyle)
{
LabelStyleContent = 0, //Default to content label
LabelStyleHeader,
};
...
@property LabelStyle labelStyle;
@property (nonatomic, setter=setLabelAsInt:) IBInspectable NSInteger labelStyleLink;
Nel file di implementazione:
- (void)setLabelAsInt:(NSInteger)value
{
self.labelStyle = (LabelStyle)value;
}
Facoltativamente, potresti aggiungere un po 'di logica per assicurarti che sia impostato su un valore valido
Sikhapol è corretto, le enumerazioni non sono ancora supportate anche non in xCode 9. Credo che l'approccio più sicuro sia usare le enumerazioni come stringhe e implementare una variabile IBInspectable "shadow" (privata). Ecco un esempio di un elemento BarBtnPaintCode che rappresenta un elemento barbutton che può essere abbinato a un'icona personalizzata (che viene eseguita utilizzando PaintCode) direttamente all'interno di Interface Builder (swift 4).
Nella build dell'interfaccia devi solo inserire la stringa (identica al valore enum), che lo mantiene chiaro (se stai inserendo numeri nessuno sa cosa significano)
class BarBtnPaintCode: BarBtnPaintCodeBase {
enum TypeOfButton: String {
case cancel
case ok
case done
case edit
case scanQr
//values used for tracking if wrong input is used
case uninitializedLoadedFromStoryboard
case unknown
}
var typeOfButton = TypeOfButton.uninitializedLoadedFromStoryboard
@IBInspectable private var type : String {
set {
typeOfButton = TypeOfButton(rawValue: newValue) ?? .unknown
setup()
}
get {
return typeOfButton.rawValue
}
}
required init?(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
setup()
}
init(typeOfButton: TypeOfButton, title: String? = nil, target: AnyObject?, action: Selector) {
super.init()
self.typeOfButton = typeOfButton
setup()
self.target = target
self.action = action
self.title = title
}
override func setup() {
//same for all
setTitleTextAttributes([NSAttributedStringKey.font : UIFont.defaultFont(size: 15)],for: UIControlState.normal)
//depending on the type
switch typeOfButton {
case .cancel :
title = nil
image = PaintCode.imageOfBarbtn_cancel(language: currentVisibleLanguage)
case .ok :
title = nil
image = PaintCode.imageOfBarbtn_ok(language: currentVisibleLanguage)
case .done :
title = nil
image = PaintCode.imageOfBarbtn_done(language: currentVisibleLanguage)
case .edit :
title = nil
image = PaintCode.imageOfBarbtn_edit(language: currentVisibleLanguage)
case .uninitializedLoadedFromStoryboard :
title = nil
image = PaintCode.imageOfBarbtn_unknown
break
case .unknown:
log.error("BarBtnPaintCode used with unrecognized type")
title = nil
image = PaintCode.imageOfBarbtn_unknown
break
}
}
}
Come ha risposto @sikhapol, questo non è possibile. La soluzione alternativa che uso per questo è avere un mucchio di IBInspectablebool nella mia classe e selezionarne uno nel generatore di interfacce. Per una maggiore sicurezza che non siano impostati più di uno, aggiungi un NSAssertsetter per ciascuno.
- (void)setSomeBool:(BOOL)flag
{
if (flag)
{
NSAssert(!_someOtherFlag && !_someThirdFlag, @"Only one flag can be set");
}
}
Questo è un po 'noioso e un po' sciatto IMO, ma è l'unico modo per realizzare questo tipo di comportamento a cui posso pensare
Voglio aggiungere che gli identificatori di un enumnon sono disponibili in fase di esecuzione per nessuno in Objective-C. Quindi non ci può essere la possibilità di visualizzarlo ovunque.