objc2_event_kit/generated/

EKEvent.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
use objc2_foundation::*;

use crate::*;

/// [Apple's documentation](https://developer.apple.com/documentation/eventkit/ekeventavailability?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct EKEventAvailability(pub NSInteger);
impl EKEventAvailability {
    #[doc(alias = "EKEventAvailabilityNotSupported")]
    pub const NotSupported: Self = Self(-1);
    #[doc(alias = "EKEventAvailabilityBusy")]
    pub const Busy: Self = Self(0);
    #[doc(alias = "EKEventAvailabilityFree")]
    pub const Free: Self = Self(1);
    #[doc(alias = "EKEventAvailabilityTentative")]
    pub const Tentative: Self = Self(2);
    #[doc(alias = "EKEventAvailabilityUnavailable")]
    pub const Unavailable: Self = Self(3);
}

unsafe impl Encode for EKEventAvailability {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

unsafe impl RefEncode for EKEventAvailability {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

/// [Apple's documentation](https://developer.apple.com/documentation/eventkit/ekeventstatus?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct EKEventStatus(pub NSInteger);
impl EKEventStatus {
    #[doc(alias = "EKEventStatusNone")]
    pub const None: Self = Self(0);
    #[doc(alias = "EKEventStatusConfirmed")]
    pub const Confirmed: Self = Self(1);
    #[doc(alias = "EKEventStatusTentative")]
    pub const Tentative: Self = Self(2);
    #[doc(alias = "EKEventStatusCanceled")]
    pub const Canceled: Self = Self(3);
}

unsafe impl Encode for EKEventStatus {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

unsafe impl RefEncode for EKEventStatus {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

extern_class!(
    /// The EKEvent class represents an occurrence of an event.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/eventkit/ekevent?language=objc)
    #[unsafe(super(EKCalendarItem, EKObject, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(all(feature = "EKCalendarItem", feature = "EKObject"))]
    pub struct EKEvent;
);

#[cfg(all(feature = "EKCalendarItem", feature = "EKObject"))]
unsafe impl NSObjectProtocol for EKEvent {}

#[cfg(all(feature = "EKCalendarItem", feature = "EKObject"))]
impl EKEvent {
    extern_methods!(
        #[cfg(feature = "EKEventStore")]
        /// Creates a new autoreleased event object.
        #[unsafe(method(eventWithEventStore:))]
        #[unsafe(method_family = none)]
        pub unsafe fn eventWithEventStore(event_store: &EKEventStore) -> Retained<EKEvent>;

        /// A unique identifier for this event.
        ///
        /// This identifier can be used to look the event up using [EKEventStore eventWithIdentifier:].
        /// You can use this not only to simply fetch the event, but also to validate the event
        /// has not been deleted out from under you when you get an external change notification
        /// via the EKEventStore database changed notification. If eventWithIdentifier: returns nil,
        /// the event was deleted.
        ///
        /// Please note that if you change the calendar of an event, this ID will likely change. It is
        /// currently also possible for the ID to change due to a sync operation. For example, if
        /// a user moved an event on a different client to another calendar, we'd see it as a
        /// completely new event here.
        ///
        /// This may be nil for events that have not been saved.
        #[unsafe(method(eventIdentifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn eventIdentifier(&self) -> Option<Retained<NSString>>;

        /// Indicates this event is an 'all day' event.
        #[unsafe(method(isAllDay))]
        #[unsafe(method_family = none)]
        pub unsafe fn isAllDay(&self) -> bool;

        /// Setter for [`isAllDay`][Self::isAllDay].
        #[unsafe(method(setAllDay:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setAllDay(&self, all_day: bool);

        /// The start date for the event.
        ///
        /// This property represents the start date for this event. Floating events (such
        /// as all-day events) are currently always returned in the default time zone.
        /// ([NSTimeZone defaultTimeZone])
        ///
        /// This will be nil for new events until you set it.
        #[unsafe(method(startDate))]
        #[unsafe(method_family = none)]
        pub unsafe fn startDate(&self) -> Retained<NSDate>;

        /// Setter for [`startDate`][Self::startDate].
        #[unsafe(method(setStartDate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setStartDate(&self, start_date: Option<&NSDate>);

        /// The end date for the event.
        ///
        /// This will be nil for new events until you set it.
        #[unsafe(method(endDate))]
        #[unsafe(method_family = none)]
        pub unsafe fn endDate(&self) -> Retained<NSDate>;

        /// Setter for [`endDate`][Self::endDate].
        #[unsafe(method(setEndDate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setEndDate(&self, end_date: Option<&NSDate>);

        #[cfg(feature = "EKStructuredLocation")]
        /// Allows you to set a structured location (a location with a potential geo-coordinate) on an
        /// event. The getter for EKEvent’s location property just returns the structured location’s title.
        /// The setter for EKEvent’s location property is equivalent to
        /// [event setStructuredLocation:[EKStructuredLocation locationWithTitle:…]].
        #[unsafe(method(structuredLocation))]
        #[unsafe(method_family = none)]
        pub unsafe fn structuredLocation(&self) -> Option<Retained<EKStructuredLocation>>;

        #[cfg(feature = "EKStructuredLocation")]
        /// Setter for [`structuredLocation`][Self::structuredLocation].
        #[unsafe(method(setStructuredLocation:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setStructuredLocation(
            &self,
            structured_location: Option<&EKStructuredLocation>,
        );

        /// Comparison function you can pass to sort NSArrays of EKEvents by start date.
        #[unsafe(method(compareStartDateWithEvent:))]
        #[unsafe(method_family = none)]
        pub unsafe fn compareStartDateWithEvent(&self, other: &EKEvent) -> NSComparisonResult;

        #[cfg(feature = "EKParticipant")]
        /// The organizer of this event, or nil.
        #[unsafe(method(organizer))]
        #[unsafe(method_family = none)]
        pub unsafe fn organizer(&self) -> Option<Retained<EKParticipant>>;

        /// The availability setting for this event.
        ///
        /// The availability setting is used by CalDAV and Exchange servers to indicate
        /// how the time should be treated for scheduling. If the calendar the event is
        /// currently in does not support event availability, EKEventAvailabilityNotSupported
        /// is returned.
        #[unsafe(method(availability))]
        #[unsafe(method_family = none)]
        pub unsafe fn availability(&self) -> EKEventAvailability;

        /// Setter for [`availability`][Self::availability].
        #[unsafe(method(setAvailability:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setAvailability(&self, availability: EKEventAvailability);

        /// The status of the event.
        ///
        /// While the status offers four different values in the EKEventStatus enumeration,
        /// in practice, the only actionable and reliable status is canceled. Any other status
        /// should be considered informational at best. You cannot set this property. If you
        /// wish to cancel an event, you should simply remove it using removeEvent:.
        #[unsafe(method(status))]
        #[unsafe(method_family = none)]
        pub unsafe fn status(&self) -> EKEventStatus;

        /// Represents whether this event is detached from a recurring series.
        ///
        /// If this EKEvent is an instance of a repeating event, and an attribute of this
        /// EKEvent has been changed from the default value generated by the repeating event,
        /// isDetached will return YES. If the EKEvent is unchanged from its default state, or
        /// is not a repeating event, isDetached returns NO.
        #[unsafe(method(isDetached))]
        #[unsafe(method_family = none)]
        pub unsafe fn isDetached(&self) -> bool;

        /// The occurrence date of an event if it is part of a recurring series.
        ///
        /// This is only set if the event is part of a recurring series. It returns
        /// the date on which this event was originally scheduled to occur. For occurrences
        /// that are unmodified from the recurring series, this is the same as the start date.
        /// This value will remain the same even if the event has been detached and its start
        /// date has changed. Floating events (such as all-day events) are currently returned
        /// in the default time zone. ([NSTimeZone defaultTimeZone])
        ///
        /// This will be nil for new events until you set startDate.
        #[unsafe(method(occurrenceDate))]
        #[unsafe(method_family = none)]
        pub unsafe fn occurrenceDate(&self) -> Option<Retained<NSDate>>;

        /// Refreshes an event object to ensure it's still valid.
        ///
        /// When the database changes, your application is sent an EKEventStoreChangedNotification
        /// note. You should generally consider all EKEvent instances to be invalid as soon as
        /// you receive the notification. However, for events you truly care to keep around, you
        /// can call this method. It ensures the record is still valid by ensuring the event and
        /// start date are still valid. It also attempts to refresh all properties except those
        /// you might have modified. If this method returns NO, the record has been deleted or is
        /// otherwise invalid. You should not continue to use it. If it returns YES, all is still
        /// well, and the record is ready for continued use. You should only call this method on
        /// events that are more critical to keep around if possible, such as an event that is
        /// being actively edited, as this call is fairly heavyweight. Do not use it to refresh
        /// the entire selected range of events you might have had selected. It is mostly pointless
        /// anyway, as recurrence information may have changed.
        #[unsafe(method(refresh))]
        #[unsafe(method_family = none)]
        pub unsafe fn refresh(&self) -> bool;

        /// Specifies the contact identifier of the person this event was created for.
        ///
        /// This property is only valid for events in the built-in Birthdays calendar. It specifies
        /// the contact identifier (for use with the Contacts framework) of the person this event was
        /// created for. For any other type of event, this property returns nil.
        #[unsafe(method(birthdayContactIdentifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn birthdayContactIdentifier(&self) -> Option<Retained<NSString>>;

        /// Specifies the address book ID of the person this event was created for.
        ///
        /// This property is only valid for events in the built-in Birthdays calendar. It specifies
        /// the Address Book ID of the person this event was created for. For any other type of event,
        /// this property returns -1.
        #[unsafe(method(birthdayPersonID))]
        #[unsafe(method_family = none)]
        pub unsafe fn birthdayPersonID(&self) -> NSInteger;

        /// Specifies the address book unique ID of the person this event was created for.
        ///
        /// This property is only valid for events in the built-in Birthdays calendar. It specifies
        /// the Address Book unique ID of the person this event was created for. For any other type of event,
        /// this property returns nil.
        #[deprecated = "Use birthdayContactIdentifier instead"]
        #[unsafe(method(birthdayPersonUniqueID))]
        #[unsafe(method_family = none)]
        pub unsafe fn birthdayPersonUniqueID(&self) -> Option<Retained<NSString>>;
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(all(feature = "EKCalendarItem", feature = "EKObject"))]
impl EKEvent {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}