# Coding Headstart

- `Download example`

A PyObjC Example without documentation

## Sources

### AppController.py

    import objc
    from CalendarStore import CalCalendarStore, CalEvent, CalTask
    from Cocoa import NSApp, NSApplication, NSDate, NSLog, NSObject

    class AppController(NSObject):
        mainWindow = objc.IBOutlet()
        taskCreationDialog = objc.IBOutlet()
        priorityPopup = objc.IBOutlet()
        eventCreationDialog = objc.IBOutlet()
        calendarData = objc.IBOutlet()

        calItemTitle = objc.ivar()
        calItemStartDate = objc.ivar()
        calItemEndDate = objc.ivar()

        objc.synthesize("calItemTitle", copy=True)
        objc.synthesize("calItemStartDate", copy=True)
        objc.synthesize("calItemEndDate", copy=True)

        @objc.IBAction
        def showTaskCreationDialog_(self, sender):
            # Set default values for the title, start date and priority
            # Cocoa bindings will clear out the related fields in the sheet
            self._.calItemTitle = None
            self._.calItemStartDate = NSDate.date()
            NSApp.beginSheet_modalForWindow_modalDelegate_didEndSelector_contextInfo_(
                self.taskCreationDialog,
                self.mainWindow,
                self,
                "didEndSheet:returnCode:contextInfo:",
                None,
            )

        @objc.IBAction
        def showEventCreationDialog_(self, sender):
            # Set default values for the title and start/end date
            # Cocoa bindings will clear out the related fields in the sheet
            self._.calItemTitle = None
            self._.calItemStartDate = NSDate.date()
            self._.calItemEndDate = NSDate.dateWithTimeIntervalSinceNow_(3600)
            NSApp.beginSheet_modalForWindow_modalDelegate_didEndSelector_contextInfo_(
                self.eventCreationDialog,
                self.mainWindow,
                self,
                "didEndSheet:returnCode:contextInfo:",
                None,
            )

        # Called when the "Add" button is pressed on the event/task entry sheet
        # This starts the sheet dismissal process
        @objc.IBAction
        def dismissDialog_(self, sender):
            NSApp.endSheet_(sender.window())

        @objc.selectorFor(
            NSApplication.beginSheet_modalForWindow_modalDelegate_didEndSelector_contextInfo_
        )
        def didEndSheet_returnCode_contextInfo_(self, sheet, returnCode, contextInfo):
            # Find out which calendar was selected for the new event/task
            # We do this using the calendarData array controller which is bound to
            # the calendar popups in the sheet
            selectedCalendar = None
            count = len(self.calendarData.selectedObjects())
            if count > 0:
                selectedCalendarUID = self.calendarData.selectedObjects()[0].uid()
                selectedCalendar = CalCalendarStore.defaultCalendarStore().calendarWithUID_(
                    selectedCalendarUID
                )

            # Create an event/task based on which sheet was used
            if sheet is self.taskCreationDialog:
                if self._.calItemTitle is None:
                    self._.calItemTitle = "My Task"

                self.createNewTaskWithCalendar_title_priority_dueDate_(
                    selectedCalendar,
                    self._.calItemTitle,
                    self.priorityPopup.selectedTag(),
                    self._.calItemStartDate,
                )

            else:
                if self._.calItemTitle is None:
                    self._.calItemTitle = "My Event"

                self.createNewEventWithCalendar_title_startDate_endDate_(
                    selectedCalendar,
                    self._.calItemTitle,
                    self._.calItemStartDate,
                    self._.calItemEndDate,
                )

            # Dismiss the sheet
            sheet.orderOut_(self)

        def createNewEventWithCalendar_title_startDate_endDate_(
            self, calendar, title, startDate, endDate
        ):
            # Create a new CalEvent object
            newEvent = CalEvent.event()

            # Set the calendar, title, start date and end date on the new event
            # using the parameters passed to this method
            newEvent._.calendar = calendar
            newEvent._.title = title
            newEvent._.startDate = startDate
            newEvent._.endDate = endDate

            # Save the new event to the calendar store (CalCalendarStore) and
            # return it
            res, err = CalCalendarStore.defaultCalendarStore().saveEvent_span_error_(
                newEvent, 0, None
            )
            if res:
                return newEvent

            NSLog("error:%@", err.localizedDescription())
            return None

        def createNewTaskWithCalendar_title_priority_dueDate_(
            self, calendar, title, priority, dueDate
        ):
            # Create a new CalTask object
            newTask = CalTask.task()

            # Set the calendar, title, priority and due date on the new task
            # using the parameters passed to this method
            newTask._.calendar = calendar
            newTask._.title = title
            newTask._.priority = priority
            newTask._.dueDate = dueDate

            # Save the new task to the calendar store (CalCalendarStore) and
            # return it
            res, err = CalCalendarStore.defaultCalendarStore().saveTask_error_(
                newTask, None
            )
            if res:
                return newTask

            NSLog("error:%@", err.localizedDescription())
            return None

### CalController.py

    """
    Bindings and notification support for Calendar data used
    by this application.  Exposes read-only collections
    (calendars, events, tasks) as observable entities.
    """
    from CalendarStore import (
        CalCalendarsChangedExternallyNotification,
        CalCalendarsChangedNotification,
        CalCalendarStore,
        CalEventsChangedExternallyNotification,
        CalEventsChangedNotification,
        CalPriorityHigh,
        CalPriorityMedium,
        CalTasksChangedExternallyNotification,
        CalTasksChangedNotification,
    )
    from Cocoa import NSDate, NSNotificationCenter, NSObject, NSString, NSValueTransformer

    highPriority = "High"
    normPriority = "Normal"
    lowPriority = "Low"
    nonePriority = "None"

    class CalPriorityToStringTransformer(NSValueTransformer):
        """
        The CalPriorityToStringTransformer class allows easy conversion between
        CalPriority values (0-9) and human-readable priority strings (High,
        Normal, Low, None). This allows us to populate the priority dropdown
        using bindings
        """

        @classmethod
        def transformedValueClass(cls):
            return type(NSString)

        @classmethod
        def allowsReverseTransformation(cls):
            return False

        def transformedValue_(self, value):
            priority = value.unsignedIntValue()
            if priority < CalPriorityHigh:
                return nonePriority

            elif priority < CalPriorityMedium:
                return highPriority

            elif priority == CalPriorityMedium:
                return normPriority

            return lowPriority

    class CalController(NSObject):
        def awakeFromNib(self):
            # Register a transformer object for easy generation of
            # human-readable priority strings
            #
            # See CalPriorityToStringTransformer implementation below

            prioTransformer = CalPriorityToStringTransformer.alloc().init()
            NSValueTransformer.setValueTransformer_forName_(
                prioTransformer, "CalPriorityToStringTransformer"
            )

            # Register for notifications on calendars, events and tasks so we can
            # update the GUI to reflect any changes beneath us
            NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(
                self, "calendarsChanged:", CalCalendarsChangedExternallyNotification, None
            )

            NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(
                self, "calendarsChanged:", CalCalendarsChangedNotification, None
            )

            NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(
                self, "eventsChanged:", CalEventsChangedExternallyNotification, None
            )

            NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(
                self, "eventsChanged:", CalEventsChangedNotification, None
            )

            NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(
                self, "tasksChanged:", CalTasksChangedExternallyNotification, None
            )

            NSNotificationCenter.defaultCenter().addObserver_selector_name_object_(
                self, "tasksChanged:", CalTasksChangedNotification, None
            )

        # Set up the read-only calendars/events/tasks arrays from Calendar Store
        # as observable keys for Cocoa Bindings
        # This in conjunction with the notifications will allow for immediate UI
        # updates whenever calendar data changes outside of this app
        def calendars(self):
            return CalCalendarStore.defaultCalendarStore().calendars()

        def events(self):
            store = CalCalendarStore.defaultCalendarStore()
            # Pull all events starting now from all calendars in the CalendarStore
            allEventsPredicate = (
                CalCalendarStore.eventPredicateWithStartDate_endDate_calendars_(
                    NSDate.date(), NSDate.distantFuture(), store.calendars()
                )
            )
            return store.eventsWithPredicate_(allEventsPredicate)

        def tasks(self):
            store = CalCalendarStore.defaultCalendarStore()
            # Pull all uncompleted tasks from all calendars in the CalendarStore
            return store.tasksWithPredicate_(
                CalCalendarStore.taskPredicateWithUncompletedTasks_(store.calendars())
            )

        # With the observable keys set up above and the appropriate bindings in IB,
        # we can trigger UI updates just by signaling changes to the keys
        def calendarsChanged_(self, notification):
            self.willChangeValueForKey_("calendars")
            self.didChangeValueForKey_("calendars")

        def eventsChanged_(self, notification):
            self.willChangeValueForKey_("events")
            self.didChangeValueForKey_("events")

        def tasksChanged_(self, notification):
            self.willChangeValueForKey_("tasks")
            self.didChangeValueForKey_("tasks")

### main.py

    import AppController  # noqa: F401
    import CalController  # noqa: F401
    import objc
    from PyObjCTools import AppHelper

    objc.setVerbose(True)

    AppHelper.runEventLoop()

### setup.py

    """
    Script for building the example.

    Usage:
        python3 setup.py py2app
    """
    from setuptools import setup

    setup(
        name="PyCalendarStore",
        app=["main.py"],
        data_files=["English.lproj"],
        setup_requires=[
            "py2app",
            "pyobjc-framework-CalendarStore",
            "pyobjc-framework-Cocoa",
        ],
    )