path: root/shell/Evolution-Storage.idl

/* -*- Mode: IDL; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 * Storage interface for the Evolution shell.
 *
 * Authors:
 *   Ettore Perazzoli <ettore@ximian.com>
 *
 * Copyright (C) 2000, 2001 Ximian, Inc.
 */

#include <Bonobo.h>

module GNOME {
module Evolution {
    interface Storage;
    interface StorageListener;

    interface Storage : Bonobo::Unknown {
        exception AlreadyListening {};
        exception NotFound {};

        enum Result {
            OK,
            UNSUPPORTED_OPERATION,
            UNSUPPORTED_TYPE,
            INVALID_URI,
            ALREADY_EXISTS,
            DOES_NOT_EXIST,
            PERMISSION_DENIED,
            NO_SPACE,
            NOT_EMPTY,
            GENERIC_ERROR
        };

        struct FolderResult {
            Result result;
            string path;
        };

        /* The name of the storage.  */
        readonly attribute string name;

        /* Whether the storage has folders from other user's.  */
        readonly attribute boolean hasSharedFolders;

        /* Get information for a folder.  NOTE: evolutionUri in the
           returned Folder is going to be an empty string if you use
           this function.  */
        Folder getFolderAtPath (in string path)
            raises (NotFound);
        
        /* Flat list of the folders in the storage.  */
        readonly attribute FolderList folderList;

        /* The folder property items (for right-click menu etc.).  */

        struct FolderPropertyItem {
            string label;
            string tooltip;
            Icon icon; // Currently unused
        };
        typedef sequence<FolderPropertyItem> FolderPropertyItemList;

        readonly attribute FolderPropertyItemList folderPropertyItems;

        /* Folder Operations.  */

        void asyncCreateFolder (in string path,
                    in string type,
                    in string description,
                    in string parent_physical_uri,
                    in Bonobo::Listener listener);

        void asyncRemoveFolder (in string path,
                    in string physical_uri,
                    in Bonobo::Listener listener);

        void asyncXferFolder (in string source_path,
                      in string destination_path,
                      in boolean remove_source,
                      in Bonobo::Listener listener);

        /* Open remote nodes.  */
        void asyncOpenFolder (in string path);

        /* Set unread count.  */
        void updateFolder (in string path,
                   in long unread_count);

        /* Shared folders.  */
        void asyncDiscoverSharedFolder (in string user,
                        in string folder_name,
                        in Bonobo::Listener listener);

        /* Listener handling.  */
        void addListener (in StorageListener listener)
            raises (AlreadyListening);
        void removeListener (in StorageListener listener)
            raises (NotFound);

        /* (This should probably be in a separate interface, but
           creating a new interface in Bonobo is so painful that I'll
           just keep it here for now.  */
        void showFolderProperties (in string path,
                       in short itemNumber,
                       in long parentWindowId);
    };

    interface StorageListener {
        exception Exists {};
        exception NotFound {};

        void notifyDestroyed ();

        /* FIXME exceptions don't make much sense here...  */

        void notifyFolderCreated (in string path,
                      in Folder folder)
            raises (Exists);
        
        void notifyFolderUpdated (in string path,
                      in long   unread_count)
            raises (NotFound);

        void notifyFolderRemoved (in string path)
            raises (NotFound);

        void notifyHasSubfolders (in string path,
                      in string message)
            raises (NotFound);
    };

    interface StorageRegistry : Bonobo::Unknown {
        exception Exists {};
        exception NotFound {};
        exception AlreadyListening {};

        typedef sequence<Storage> StorageList;
        
        enum MessageType {
            STORAGE_CREATED,
            STORAGE_DESTROYED
        };

        struct NotifyResult {
            MessageType type;
            string name;
        };
        
        StorageListener addStorage (in Storage storage,
                        in string name)
            raises (Exists);

        StorageList getStorageList ();
        
        Storage getStorageByName (in string name)
            raises (NotFound);

        void removeStorageByName (in string name)
            raises (NotFound);

        void addListener (in Bonobo::Listener listener)
            raises (AlreadyListening);

        void removeListener (in Bonobo::Listener listener)
            raises (NotFound);

        Folder getFolderByUri (in string uri)
            raises (NotFound);
    };
};
};