DragApp¶
This example shows one possible way of implementing Drag and Drop for
tableviews using bindings and core data. Our purpose is to provide a simple UI
for adding members from a pool of all people into a club. The focus of this
example is the NSObject subclass named DragSupportDataSource. All of
the table views in the application UI are bound to an array controller but
have their data source set to a single DragSupportDataSource.
NSTableView drag and drop methods are called on the table view’s datasource.
Using infoForBinding API, the DragSupportDataSource can find out which
arraycontroller the table view in the drag operation is bound to. Once the
destination array controller is found, it’s simple to perform the correct
operations.
The data source methods implemented by the DragSupportDataSource return
None/0 so that the normal bindings machinery will populate the table
view with data. This may seem like a waste, but is a simple way of letting the
DragSupportDataSource do the work of registering the table views for
dragging. See DragSupportDataSource.py for more information.
Things to keep in mind:
The drag and drop implementation assumes all controllers are working with the same
NSManagedObjectContextMost of the code in the
DragSupportDataSourceis for error checking and un/packing objects
Sources¶
DragAppAppDelegate.py¶
import Cocoa
import CoreData
import objc
class DragAppAppDelegate(Cocoa.NSObject):
clubWindow = objc.IBOutlet()
peopleWindow = objc.IBOutlet()
_managedObjectModel = objc.ivar()
_managedObjectContext = objc.ivar()
_things = objc.ivar()
def managedObjectModel(self):
if self._managedObjectModel is None:
allBundles = Cocoa.NSMutableSet.alloc().init()
allBundles.addObject_(Cocoa.NSBundle.mainBundle())
allBundles.addObjectsFromArray_(Cocoa.NSBundle.allFrameworks())
self._managedObjectModel = (
CoreData.NSManagedObjectModel.mergedModelFromBundles_(
allBundles.allObjects()
)
)
return self._managedObjectModel
# Change this path/code to point to your App's data store.
def applicationSupportFolder(self):
paths = Cocoa.NSSearchPathForDirectoriesInDomains(
Cocoa.NSApplicationSupportDirectory, Cocoa.NSUserDomainMask, True
)
if len(paths) == 0:
Cocoa.NSRunAlertPanel(
"Alert", "Can't find application support folder", "Quit", None, None
)
Cocoa.NSApplication.sharedApplication().terminate_(self)
else:
applicationSupportFolder = paths[0].stringByAppendingPathComponent_(
"DragApp"
)
return applicationSupportFolder
def managedObjectContext(self):
if self._managedObjectContext is None:
fileManager = Cocoa.NSFileManager.defaultManager()
applicationSupportFolder = self.applicationSupportFolder()
if not fileManager.fileExistsAtPath_isDirectory_(
applicationSupportFolder, None
)[0]:
fileManager.createDirectoryAtPath_attributes_(
applicationSupportFolder, None
)
url = Cocoa.NSURL.fileURLWithPath_(
applicationSupportFolder.stringByAppendingPathComponent_("DragApp.xml")
)
coordinator = CoreData.NSPersistentStoreCoordinator.alloc().initWithManagedObjectModel_( # noqa: B950
self.managedObjectModel()
)
(
result,
error,
) = coordinator.addPersistentStoreWithType_configuration_URL_options_error_(
CoreData.NSXMLStoreType, None, url, None, None
)
if result:
self._managedObjectContext = (
CoreData.NSManagedObjectContext.alloc().init()
)
self._managedObjectContext.setPersistentStoreCoordinator_(coordinator)
else:
Cocoa.NSApplication.sharedApplication().presentError_(error)
return self._managedObjectContext
def windowWillReturnUndoManager_(self, window):
return self.managedObjectContext().undoManager()
@objc.IBAction
def saveAction_(self, sender):
res, error = self.managedObjectContext().save_(None)
if not res:
Cocoa.NSApplication.sharedApplication().presentError_(error)
def applicationShouldTerminate_(self, sender):
context = self.managedObjectContext()
reply = Cocoa.NSTerminateNow
if context is not None:
if context.commitEditing():
res, error = context.save_(None)
if not res:
# This default error handling implementation should be
# changed to make sure the error presented includes
# application specific error recovery. For now, simply
# display 2 panels.
errorResult = Cocoa.NSApplication.sharedApplication().presentError_(
error
)
if errorResult: # Then the error was handled
reply = Cocoa.NSTerminateCancel
else:
# Error handling wasn't implemented. Fall back to
# displaying a "quit anyway" panel.
alertReturn = Cocoa.NSRunAlertPanel(
None,
"Could not save changes while quitting. Quit anyway?",
"Quit anyway",
"Cancel",
None,
)
if alertReturn == Cocoa.NSAlertAlternateReturn:
reply = Cocoa.NSTerminateCancel
else:
reply = Cocoa.NSTerminateCancel
return reply
DragSupportDataSource.py¶
"""
Abstract: Custom that handles Drag and Drop for table views by acting as a datasource.
"""
import Cocoa
import objc
from objc import super # noqa: A004
class DragSupportDataSource(Cocoa.NSObject):
# all the table views for which self is the datasource
registeredTableViews = objc.ivar()
def init(self):
self = super().init()
if self is None:
return None
self.registeredTableViews = Cocoa.NSMutableSet.alloc().init()
return self
# ******** table view data source necessities *********
# We use this method as a way of registering for drag types for all
# the table views that will depend on us to implement D&D. Instead of
# setting up innumerable outlets, simply depend on the fact that every
# table view will ask its datasource for number of rows.
def numberOfRowsInTableView_(self, aTableView):
# this is potentially slow if there are lots of table views
if not self.registeredTableViews.containsObject_(aTableView):
aTableView.registerForDraggedTypes_([Cocoa.NSStringPboardType])
# Cache the table views that have "registered" with us.
self.registeredTableViews.addObject_(aTableView)
# return 0 so the table view will fall back to getting data from
# its binding
return 0
def tableView_objectValueForTableColumn_row_(self, aView, aColumn, rowIdx):
# return None so the table view will fall back to getting data from
# its binding
return None
# put the managedobject's ID on the pasteboard as an URL
def tableView_writeRowsWithIndexes_toPasteboard_(self, tv, rowIndexes, pboard):
success = False
infoForBinding = tv.infoForBinding_(Cocoa.NSContentBinding)
if infoForBinding is not None:
arrayController = infoForBinding.objectForKey_(Cocoa.NSObservedObjectKey)
objects = arrayController.arrangedObjects().objectsAtIndexes_(rowIndexes)
objectIDs = Cocoa.NSMutableArray.array()
for i in range(objects.count()):
item = objects[i]
objectID = item.objectID()
representedURL = objectID.URIRepresentation()
objectIDs.append(representedURL)
pboard.declareTypes_owner_([Cocoa.NSStringPboardType], None)
pboard.addTypes_owner_([Cocoa.NSStringPboardType], None)
success = pboard.setString_forType_(
objectIDs.componentsJoinedByString_(", "), Cocoa.NSStringPboardType
)
return success
# *************** actual drag and drop work *****************
def tableView_validateDrop_proposedRow_proposedDropOperation_(
self, tableView, info, row, operation
):
# Avoid drag&drop on self. This might be interersting to enable in
# light of ordered relationships
if info.draggingSource() is not tableView:
return Cocoa.NSDragOperationCopy
else:
return Cocoa.NSDragOperationNone
def tableView_acceptDrop_row_dropOperation_(self, tableView, info, row, operation):
success = False
urlStrings = info.draggingPasteboard().stringForType_(Cocoa.NSStringPboardType)
# get to the arraycontroller feeding the destination table view
destinationContentBindingInfo = tableView.infoForBinding_(
Cocoa.NSContentBinding
)
if destinationContentBindingInfo is not None:
destinationArrayController = destinationContentBindingInfo.objectForKey_(
Cocoa.NSObservedObjectKey
)
sourceArrayController = None
# check for the arraycontroller feeding the source table view
contentSetBindingInfo = destinationArrayController.infoForBinding_(
Cocoa.NSContentSetBinding
)
if contentSetBindingInfo is not None:
sourceArrayController = contentSetBindingInfo.objectForKey_(
Cocoa.NSObservedObjectKey
)
# there should be exactly one item selected in the source controller, otherwise
# the destination controller won't be able to manipulate the relationship when
# we do addObject:
if (sourceArrayController is not None) and (
sourceArrayController.selectedObjects().count() == 1
):
context = destinationArrayController.managedObjectContext()
destinationControllerEntity = Cocoa.NSEntityDescription.entityForName_inManagedObjectContext_( # noqa: B950
destinationArrayController.entityName(), context
)
items = urlStrings.split(", ")
itemsToAdd = []
for i in range(len(items)):
urlString = items[i]
# take the URL and get the managed object - assume
# all controllers using the same context
url = Cocoa.NSURL.URLWithString_(urlString)
objectID = context.persistentStoreCoordinator().managedObjectIDForURIRepresentation_( # noqa: B950
url
)
if objectID is not None:
value = context.objectRegisteredForID_(objectID)
# make sure objects match the entity expected by
# the destination controller, and not already there
if (
value is not None
and (value.entity() is destinationControllerEntity)
and not (
destinationArrayController.arrangedObjects().containsObject_(
value
)
)
):
itemsToAdd.append(value)
if len(itemsToAdd) > 0:
destinationArrayController.addObjects_(itemsToAdd)
success = True
return success
main.py¶
import DragAppAppDelegate # noqa: F401
import DragSupportDataSource # noqa: F401
from PyObjCTools import AppHelper
if __name__ == "__main__":
AppHelper.runEventLoop()
setup.py¶
"""
Script for building the example.
Usage:
python3 setup.py py2app
"""
from setuptools import setup
setup(
name="DragApp",
app=["main.py"],
data_files=["English.lproj"],
options={"py2app": {"datamodels": ["DragApp_DataModel.xcdatamodel"]}},
setup_requires=["py2app", "pyobjc-framework-Cocoa", "pyobjc-framework-CoreData"],
)