@dgelessus thanks so much for the deep knowledge!

So now this whole thing is working! As it turns out a lot of this was a red herring.

In summary:

• It is perfectly legal to use the python string value "UICollectionElementKindSectionHeader" directly in the registerClass_forSupplementaryViewOfKind_withReuseIdentifier_() objc method, since it is converted to an NSString object implicitly.
• The value returned by ctypes.c_void_p.in_dll(objc_util.c, "UICollectionElementKindSectionHeader") works as well, I assume since that c_void_p ends up being interpreted as an NSString object.
• Of course, objc_util.ObjCInstance(ctypes.c_void_p.in_dll(objc_util.c, "UICollectionElementKindSectionHeader")) works, and is probably "safest" since you get the actual value without having to guess, and it is turned into a correct type.
• You cannot directly use the _FuncPtr value returned by objc_util.c.UICollectionElementKindSectionHeader but there might be some way to convert that _FuncPtr value (just doing a ctypes.cast(funcptr, ctypes.c_void_p) does not work).

Now, the reason the whole thing was a red herring: collection views won't even bother to call the collectionView_viewForSupplementaryElementOfKind_atIndexPath_() method unless the flow layout object being used to layout the items has had its headerReferenceSize property set to something other than the default CGSize(0,0)...so even when I was successfully registering the class with the method to create section headers, it wasn't being called.

I did a little digging on this, to figure out how it is being solved by other developers.

First, though this would appear to many to be a bug, it actually puts the popover presentation view controller in line with how view controllers work in general. Since iOS 11+ Apple has provided a "safe area" concept which is supposed to be used by the view hierarchy to indicate what part of their content area is obscured. In the case of the popover view controller, the arrow is still part of the content area, but it obscures content.

@cvp, @mikael you are both the dudes!

I'm providing a somewhat more complex but general way below, which doesn't suffer from the delay between presentation of the popover and content. The trouble is that the safeAreaInsets() is always 0 before a view is displayed, so it can't be used to set the proper location of a view before it is visible. However, using the safeAreaLayoutGuide() and the constraint/anchor system, the content view can be made to size itself automatically to the safe area:

import ui


def present_popup(content_view, position):
    popup = ui.View(
        width=content_view.width,
        height=content_view.height,
    )
    popup.add_subview(content_view)
    
    content_view.objc_instance.translatesAutoresizingMaskIntoConstraints = False
    guide = popup.objc_instance.safeAreaLayoutGuide()
    anchor = content_view.objc_instance.leadingAnchor()
    anchor.constraintEqualToAnchor_(guide.leadingAnchor()).active = True
    anchor = content_view.objc_instance.trailingAnchor()
    anchor.constraintEqualToAnchor_(guide.trailingAnchor()).active = True
    anchor = content_view.objc_instance.topAnchor()
    anchor.constraintEqualToAnchor_(guide.topAnchor()).active = True
    anchor = content_view.objc_instance.bottomAnchor()
    anchor.constraintEqualToAnchor_(guide.bottomAnchor()).active = True

    popup.present(style="popover",
        popover_location=position,
        hide_title_bar=True)

    return popup
    
    
if __name__ == '__main__':
    
    popup_content = ui.Label(
        text="Hello!",
        border_width=3,
        frame=(0,0,150,100),
    )

    popup = present_popup(popup_content, (100, 100))

@Drizzel the important bit here is that you aren't really supposed to directly access tableview cells by index, since in all likelihood, they don't exist.

This is because the way the underlying control is implemented is designed to only create cells when they need to be displayed, and it keeps only the ones it absolutely needs to keep (with some caching), it even reuses existing cells that have gone out of the visible area, instead of creating new ones.

That source.tableview_cell_for_row() is called to generate a cell for a particular index at the moment the view requires it, and it will be destroyed or reused, so you can't really depend on it being "kept" somewhere as a subview you can always access.

Now, you can actually use objc_util magic to get a cell at an index path, but the cell will be None if that index is invalid or not visible.

So the best thing to do if you want to somehow modify a cell (I'm guessing that's what you want here) is to implement tableview_cell_for_row() and make any modifications there for cells being created. If you need to update a visible cell, just call table.reload() and it will cause all visible cells to be re-created.

@stephen not sure what SBridge is, exactly? Doesn't seem python related?

@mikael it just came up at work in recent discussions about the future of using pythonista to do rapid development. People were wondering if there was any route to swift that was as simple as it is for objective-c.

Not that Apple is planning to stop supporting objective-c in the near future, but more people are comfortable swift or with learning swift, than with picking up objective-c.

Most of what I see when googling is about calling/embedding python from swift, not the other way around (calling swift from python). There's this:

https://gist.github.com/jiaaro/e111f0f64d0cdb8aca38

But that is not something which can be integrated with pythonista.

@omz thanks for the update!

Pythonista has been unbelievably helpful at my work, and continues to impress every day.

Ah, was tired last night...this just required some googling.
The getset_descriptor is the CPython property object, and I can directly get and set the value from it with:

@property
def background_color(self):
    return ui.View.background_color.__get__(self) 
    
@background_color.setter
def background_color(self, color):
    ui.View.background_color.__set__(self, color)

@ccc brusque but true.

@TutorialDoctor to be a little more descriptive: if you are going to write an app like Pythonista, learn Swift and write it as a fully native project. Tkinter is unlikely to ever work on an iPad without enormous effort (it's also an outdated and poor choice of toolkit), and while there are modern cross-platform libraries you could work with (Flutter/Dart from Google, for example), you will surely hit limitations.

It really is so great to know you're still developing Pythonista @omz !

Truly wonderful work, can't wait for the next release!
(and if there's any chance of more open TestFlight slots, let us know).

@mikael yeah, we won't be expecting anything specific from Pythonista development. We'll probably go with something like RabbitMQ which doesn't require any compiled library extensions.

Unfortunately I can't really say anything about what I'm working on here...suffice it to say that we have to rapidly respond to client requests in an environment where development isn't macOS-based, is almost entirely python and c++, but still needed to be able to build interfaces for iOS. Pythonista checked those boxes very nicely.

If @olemoritz is listening, he should know just how good this app is.

First, here's a newer version with some improvements which make it work better on iOS 13, and adds a callback which is called when the popover is presented:

def adaptivePresentationStyleForPresentationController_(_self, _cmd,
                                                                controller):
    #### force the popover presentation style to stay as-is
    return -1 # UIModalPresentationNone

def popoverDelegateCompletion(delegate):
    if delegate._popview is not None and delegate._bgcolor is not None:
        delegate._popview.background_color = delegate._bgcolor
    if delegate._completion is not None:
        delegate._completion()
    delegate._popview = None
    delegate._presented_block = None

def popoverPresentationControllerDidDismissPopover_(_self, _cmd, controller):
    import objc_util
    delegate = objc_util.ObjCInstance(_self)
    popoverDelegateCompletion(delegate)

PopoverPresentationDelegate = objc_util.create_objc_class(
                "PopoverPresentationDelegate",
                methods=[adaptivePresentationStyleForPresentationController_,
                            popoverPresentationControllerDidDismissPopover_],
                protocols=["UIPopoverPresentationControllerDelegate"])

def popover(sourceview, popview, presented=None, dismissed=None):
    """Create and display a popover modal view containing the given
    content view, with a little arrow pointing at the given source view.
    'presented' is called when the popover is first presented.
    'dismissed' will be called when the popover is dismissed."""

    def _closer(vc, delegate):
        #### return a function object which will dismiss the popover
        #### and restore the popview bg color, as well as call
        #### any completion function
        def _f():
            vc.dismissViewControllerAnimated_completion_(True,None)
            popoverDelegateCompletion(delegate)
        return _f

    #### find the view controller which is presenting the source view
    #### this is what the popover arrow will point at
    sourcevc = ViewHierarchy.getUIViewController(sourceview)
    #### create a new modal view controller and set its presentation
    #### style to the popover style, and size it to the content
    UIViewController = objc_util.ObjCClass("UIViewController")
    vc = UIViewController.new().autorelease()
    vc.modalPresentationStyle = 7 # UIModalPresentationPopover
    vc.preferredContentSize = objc_util.CGSize(popview.width, popview.height)

    #### As of iOS 13+ popover presentation bounds include the little arrow
    #### as part of the content area.
    #### Since our popup content is designed to be displayed only in the
    #### rectangular portion of the popover view, we constrain it to
    #### the "safe area", which excludes the arrow.
    safeView = objc_util.UIView.new().autorelease()
    safeView.addSubview_(popview.objc_instance)
    safeView.backgroundColor = objc_util.UIColor.clearColor()
    vc.view = safeView
    popview.objc_instance.translatesAutoresizingMaskIntoConstraints = False
    guide = safeView.safeAreaLayoutGuide()
    anchor = popview.objc_instance.leadingAnchor()
    anchor.constraintEqualToAnchor_(guide.leadingAnchor()).active = True
    anchor = popview.objc_instance.trailingAnchor()
    anchor.constraintEqualToAnchor_(guide.trailingAnchor()).active = True
    anchor = popview.objc_instance.topAnchor()
    anchor.constraintEqualToAnchor_(guide.topAnchor()).active = True
    anchor = popview.objc_instance.bottomAnchor()
    anchor.constraintEqualToAnchor_(guide.bottomAnchor()).active = True

    #### retrieve the popover presentation controller for the new modal
    #### view controller, bail if that fails for some reason
    popover = vc.popoverPresentationController()
    if popover is None: return None

    #### create and assign the popover presentation delegate
    delegate = PopoverPresentationDelegate.new().autorelease()
    delegate._completion = dismissed
    delegate._popview = popview
    delegate._bgcolor = None
    popover.delegate = delegate

    #### if the popview has a translucent background, make the
    #### presenting view translucent instead, and the popview transparent,
    #### save the original color to restore on dismissal.
    color = popview.background_color
    if color[3] < 1.0:
        popview.background_color = "clear"
        delegate._bgcolor = color
    popover.backgroundColor = objc_util.UIColor.colorWithRed_green_blue_alpha_(*color)
    popover.sourceView = sourceview.objc_instance
    popover.sourceRect = objc_util.CGRect(objc_util.CGPoint(0,0),objc_util.CGSize(
                                            sourceview.width, sourceview.height))
    #### if a presentation function is provided, it is converted to an
    #### objective-c block to be called when the popover is displayed
    objc_f = None
    if presented is not None:
        objc_f = objc_util.ObjCBlock(presented, None, [objc_util.c_void_p])
        delegate._presented_block = objc_f
    #### present the view controller containing the popover content
    #### via the popover presentation controller, using the
    #### popover delegate we created, and return the close
    #### function to allow caller to close the popover from code
    sourcevc.presentViewController_animated_completion_(vc, True, objc_f)
    return _closer(vc, delegate)

it's simple enough to use. When you wish to display a view as a popover, just call like so:

def popover(sender):
    popview = ui.View()
    popview.width = 200
    popview.height = 100
    popview.add_subview(ui.Label(text="Hello popover!", flex="WH")
    popover(sender, popview)

v = ui.View()
v.width = 300
v.height = 300
b = ui.Button()
b.title = "Show Popover"
b.action = showPopover
b.frame = (0,0,100,40)
b.center = v.center
v.add_subview(b)
v.present("sheet")

Just wanted to say we're encountering issues with the built-in dialogs module here too.

My iPad is still on ipadOS 15, but one of my co-developers is using ipadOS 16 and he sees freezes followed by segmentation faults when the UI tries to show a dialog box using that module.

This is during testing of the "big move" of our codebase from pythonista3.3 to pythonista3.4 and python2 to python3, so we thought at first it was something we were doing, but based on this thread, I think it may definitely be a bug in the dialogs module.

@cvp searching for the prompt label is a good extra check, I like it...well, I like it a little bit more.

Monkey-patching the console module isn't really necessary...being able to call console.text isn't the part that bothered me, it's just my hope for what @omz might eventually add to the console api.

Anyway, thanks @cvp, as always!

Hrm...upon further investigation, I take it back: the above code appears to work in Pythonista3.4.

I still don't love it. It feels very fragile just "guessing" which OMTextView happens to be right like this. I really wish there was a better way...but I don't see a good way to more directly determine which view is the console view.

Anyway, the right solution is for there to be a console.text() function. So I will repeat my plea to @omz to please consider adding that to the features in the console module.

I had code from python2/pythonista3.3 which was able to find the console view in the view hierarchy, and then pull the text out of it:

def findConsoleView():
    app = objc_util.UIApplication.sharedApplication()
    if not app: return ""
    mainwindow = app.keyWindow()
    if not mainwindow: return ""
    mainview = mainwindow.rootViewController().view()
    if not mainview: return ""
    visit = list(mainview.subviews())
    while visit:
        v = visit.pop()
        if bytes(v._get_objc_classname()) == b"OMTextView":
            if v.superview() and \
                    bytes(v.superview()._get_objc_classname()) != \
                                                        b"OMTextEditorView":
                return str(v.text())
        visit += list(v.subviews())
    return ""

Sadly, this no longer works, as I think the console view no longer fits the criteria I was using to find it.

Anyone have a working version of this idea?
I'm going to plug away at searching the view hierarchy and see if I can find where the console is hiding now.

( @omz for possible future updates: it would be nice if there was a console.text() function in the console module)

Looks like rubicon may be the answer. Here's the same barometer example that crashes using objc_util converted to use rubicon:

import sys
import rubicon_objc
import time

pressure = None

def handler(data, error):
    global pressure
    data = rubicon_objc.api.ObjCInstance(data)
    error = rubicon_objc.api.ObjCInstance(error)
    print("handler called:", data, error)
    pressure = data.pressure.floatValue

handler_block = rubicon_objc.api.Block(
    handler,
    None,
    rubicon_objc.types.c_void_p,
    rubicon_objc.types.c_void_p
)

CMAltimeter = rubicon_objc.api.ObjCClass('CMAltimeter')
NSOperationQueue = rubicon_objc.api.ObjCClass('NSOperationQueue')

if not CMAltimeter.isRelativeAltitudeAvailable():
    print('This device has no barometer.')
else:
    altimeter = CMAltimeter.new()
    mainq = NSOperationQueue.mainQueue
    print("Altimeter:", altimeter)
    print("Main Queue:", mainq)

    altimeter.startRelativeAltitudeUpdatesToQueue_withHandler_(mainq,
                                                                handler_block)

    try:
        while pressure is None:
            pass
    finally:
        altimeter.stopRelativeAltitudeUpdates()

    print("got pressure:", pressure)

this doesn't crash. I don't know rubicon particularly well, so I don't know if I'm using it exactly as intended, but I'll see if it succeeds in other cases where objc_util crashes.

One more datapoint. As @JonB suggested, I tried the example for ObjCBlock in the pythonista docs for the objc_util module:

import objc_util

cheeses = objc_util.ns(['Camembert', 'Feta', 'Gorgonzola'])

print(cheeses)

def compare(_cmd, a, b):
    a = objc_util.ObjCInstance(a).length()
    b = objc_util.ObjCInstance(b).length()
    if a > b: return 1
    if a < b: return -1
    return 0

# Note: The first (hidden) argument `_cmd` is the block itself, so there are three arguments instead of two.
compare_block = objc_util.ObjCBlock(
    compare,
    restype=objc_util.NSInteger,
    argtypes=[objc_util.c_void_p, objc_util.c_void_p, objc_util.c_void_p])

sorted_cheeses = cheeses.sortedArrayUsingComparator_(compare_block)
print(sorted_cheeses)

works fine, no crashes. So, that makes it seem even more likely that this has to do with the internals of how the block is created/presented to objective-c via CFFI.

@ccc brusque but true.

@TutorialDoctor to be a little more descriptive: if you are going to write an app like Pythonista, learn Swift and write it as a fully native project. Tkinter is unlikely to ever work on an iPad without enormous effort (it's also an outdated and poor choice of toolkit), and while there are modern cross-platform libraries you could work with (Flutter/Dart from Google, for example), you will surely hit limitations.

And if I make the barometer example nearly identical in structure, it still fails, even with a time.sleep() put in:

import objc_util
import time

pressure = None

def handler(_cmd, data, error):
    global pressure
    print("handler called")
    pressure = objc_util.ObjCInstance(data).pressure()

handler_block = objc_util.ObjCBlock(
    handler,
    restype=None,
    argtypes=[objc_util.c_void_p, objc_util.c_void_p, objc_util.c_void_p]
)

CMAltimeter = objc_util.ObjCClass('CMAltimeter')
NSOperationQueue = objc_util.ObjCClass('NSOperationQueue')

if not CMAltimeter.isRelativeAltitudeAvailable():
    print('This device has no barometer.')
else:
    altimeter = CMAltimeter.new()
    mainq = NSOperationQueue.mainQueue()
    altimeter.startRelativeAltitudeUpdatesToQueue_withHandler_(mainq,
                                                               handler_block)

    try:
        while pressure is None:
            time.sleep(0)
    finally:
        altimeter.stopRelativeAltitudeUpdates()

    print("got pressure:", pressure)

so something else is going on here.
Must be something more fundamental in how the blocks are defined.

@cvp doesn't seem to be the time.sleep() that allows the reverse geocode example to work...if I strip that code down a bit, and remove the sleep, it still works without crashing:

import objc_util
import time

handler_done = None
country_code = None

def handler(_cmd, placemarks, error):
    global country_code
    global handler_done

    print('handler called')
    if not error and placemarks:
        placemarks = objc_util.ObjCInstance(placemarks)
        for placemark in placemarks:
            country_code = str(placemark.ISOcountryCode())

    handler_done = True

handler_block = objc_util.ObjCBlock(
    handler,
    restype=None,
    argtypes=[objc_util.c_void_p, objc_util.c_void_p, objc_util.c_void_p]
)

lat, lon = (37.7749, -122.4194)
CLGeocoder = objc_util.ObjCClass('CLGeocoder').alloc().init()
CLLocation = objc_util.ObjCClass('CLLocation').alloc().initWithLatitude_longitude_(lat,lon)
CLGeocoder.reverseGeocodeLocation_completionHandler_(CLLocation, handler_block)	

# wait handler called and finished
while not handler_done:
    #time.sleep(0)
    pass

print("Country Code:", country_code)

So, something else about that particular block call works.

@cvp possibly just luck that this particular script works. But maybe there's something about the way it is set up. I had not found a working example so far in any of the ways we had been using ObjCBlock, and I'd also tried a couple of examples in the forum, like that barometer one.