Implementierung von nSoutlineViewDataSource mit Monomac

Question

Ich versuche, eine Datenquelle für eine zu implementieren NSOutlineView. Das Problem ist, dass ich nicht weiß, aus welcher Art von Objekt ich zurückkehren soll outlineView:child:ofItem:.

Der aktuelle Code sieht so aus:

[Export("outlineView:child:ofItem:")]
public NSObject childOfItem(NSOutlineView outline, int child, NSObject item)
{
    return new MyItem();
}

Mit Myitem:

public class MyItem : NSObject
{}

BEARBEITEN: Mit diesem Code bekomme ich eine InvalidCastException Kurz nachdem er Myitem zurückgegeben hat.

Answer 1

Wenn Sie einen neuen Typ von erben NSOutlineViewDataSource dann solltest du nicht Wiederexport es ist outlineView:child:ofItem: Selektor für Ihre eigene Methode. Stattdessen sollten Sie das tun, wenn Sie das tun sollten GetChild Methode, die diesen Selektor bereits exportieren, z. B.

public overrride NSObject GetChild (NSOutlineView outlineView, int childIndex, NSObject ofItem)
{
    return new MyItem ();
}

Hinweis: Das hilft möglicherweise nicht, da ich es nicht ausprobiert habe (ich mache meistens Monotouch -Dinge), aber überprüfe andere Selektoren, die Sie möglicherweise neu definieren/in Ihrer Bewerbung exportieren (um festzustellen, ob Sie nicht sein sollten überschreiben-Sie von der Basisklasse aus der Basis erben, von der Sie erben).

Answer 2

Haben Sie überlegt, a zu verwenden NSTreeController? Es hilft, die Gliederungsansicht für Sie zu verwalten und ist sehr praktisch. NSTreeController Verwendet eine Klasse namens NSTreeNode Knoten in der Umrissansicht und jeweils darstellen NSTreeNode hat ein representedObject Methode, mit der Sie zum Modellobjekt gelangen können.

In jedem Fall, wenn Sie das nicht verwenden möchten NSTreeController oder NSTreeNode, Sie können Ihr Modellobjekt einfach direkt zurückgeben. Hier sind einige Beispiele für den Objektiv-C-Code von Apple Guides.

@implementation DataSource
// Data Source methods

- (NSInteger)outlineView:(NSOutlineView *)outlineView numberOfChildrenOfItem:(id)item {

    return (item == nil) ? 1 : [item numberOfChildren];
}


- (BOOL)outlineView:(NSOutlineView *)outlineView isItemExpandable:(id)item {
    return (item == nil) ? YES : ([item numberOfChildren] != -1);
}


- (id)outlineView:(NSOutlineView *)outlineView child:(NSInteger)index ofItem:(id)item {

    return (item == nil) ? [FileSystemItem rootItem] : [(FileSystemItem *)item childAtIndex:index];
}


- (id)outlineView:(NSOutlineView *)outlineView objectValueForTableColumn:(NSTableColumn *)tableColumn byItem:(id)item {
    return (item == nil) ? @"/" : [item relativePath];
}

@end


@interface FileSystemItem : NSObject
{
    NSString *relativePath;
    FileSystemItem *parent;
    NSMutableArray *children;
}

+ (FileSystemItem *)rootItem;
- (NSInteger)numberOfChildren;// Returns -1 for leaf nodes
- (FileSystemItem *)childAtIndex:(NSUInteger)n; // Invalid to call on leaf nodes
- (NSString *)fullPath;
- (NSString *)relativePath;

@end


@implementation FileSystemItem

static FileSystemItem *rootItem = nil;
static NSMutableArray *leafNode = nil;

+ (void)initialize {
    if (self == [FileSystemItem class]) {
        leafNode = [[NSMutableArray alloc] init];
    }
}

- (id)initWithPath:(NSString *)path parent:(FileSystemItem *)parentItem {
    self = [super init];
    if (self) {
       relativePath = [[path lastPathComponent] copy];
       parent = parentItem;
       }
    return self;
}


+ (FileSystemItem *)rootItem {
    if (rootItem == nil) {
        rootItem = [[FileSystemItem alloc] initWithPath:@"/" parent:nil];
    }
    return rootItem;
}


// Creates, caches, and returns the array of children
// Loads children incrementally
- (NSArray *)children {

    if (children == nil) {
        NSFileManager *fileManager = [NSFileManager defaultManager];
        NSString *fullPath = [self fullPath];
        BOOL isDir, valid;

        valid = [fileManager fileExistsAtPath:fullPath isDirectory:&isDir];

        if (valid && isDir) {
            NSArray *array = [fileManager contentsOfDirectoryAtPath:fullPath error:NULL];

            NSUInteger numChildren, i;

            numChildren = [array count];
            children = [[NSMutableArray alloc] initWithCapacity:numChildren];

            for (i = 0; i < numChildren; i++)
            {
                FileSystemItem *newChild = [[FileSystemItem alloc]
                                   initWithPath:[array objectAtIndex:i] parent:self];
                [children addObject:newChild];
                [newChild release];
            }
        }
        else {
            children = leafNode;
        }
    }
    return children;
}


- (NSString *)relativePath {
    return relativePath;
}


- (NSString *)fullPath {
    // If no parent, return our own relative path
    if (parent == nil) {
        return relativePath;
    }

    // recurse up the hierarchy, prepending each parent’s path
    return [[parent fullPath] stringByAppendingPathComponent:relativePath];
}


- (FileSystemItem *)childAtIndex:(NSUInteger)n {
    return [[self children] objectAtIndex:n];
}


- (NSInteger)numberOfChildren {
    NSArray *tmp = [self children];
    return (tmp == leafNode) ? (-1) : [tmp count];
}


- (void)dealloc {
    if (children != leafNode) {
        [children release];
    }
    [relativePath release];
    [super dealloc];
}

@end

Es ist nicht Monomac, sollte aber die gleiche Idee sein.