Mise en œuvre à l'aide NSOutlineViewDataSource Monomac

Question

Je suis en train de mettre en œuvre une source de données pour un NSOutlineView. Le problème est que je ne sais pas quel type d'objet à un retour de outlineView:child:ofItem:.

code actuel ressemble à ceci:

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

Avec MyItem:

public class MyItem : NSObject
{}

EDIT:. Avec ce code, je reçois un InvalidCastException juste après le retour MyItem

Answer 1

Si vous héritez d'un nouveau type de NSOutlineViewDataSource alors vous ne devriez pas réexportation son sélecteur de outlineView:child:ofItem: sur votre propre méthode. Au lieu de cela ce que vous devez faire est de remplacer la méthode de GetChild qui exportent déjà ce sélecteur, par exemple.

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

Note: Cela pourrait ne pas aider puisque je ne l'ai pas essayé (je fais surtout des choses MonoTouch) mais faire examen d'autres sélecteurs vous pourriez être en train de redéfinir / exporter dans votre application (pour voir si vous ne devriez pas être override les -ment de la classe de base que vous êtes héritant de).

Answer 2

Avez-vous envisagé d'utiliser un NSTreeController? Il aide à gérer la vue les grandes lignes pour vous et est très pratique. NSTreeController utilise une classe appelée NSTreeNode pour représenter les noeuds dans la vue de plan, et chaque NSTreeNode a une méthode de representedObject qui vous permettent d'obtenir de l'objet modèle.

Dans tous les cas, si vous ne voulez pas utiliser le NSTreeController ou NSTreeNode, vous pouvez simplement retourner votre modèle objet directement. Voici quelques exemples de code Objective-C des guides de pomme.

@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

Il n'est pas Monomac mais devrait être la même idée.