Re: cvs build



On Tue, Apr 08, 2003 at 06:17:17PM +0100, Michael Meeks wrote: 
> > I'm not sure you want me to commit the automake 1.7 stuff, because it
> > probably breaks distcheck in not-easy-to-fix ways.
> 
> 	I'm somewhat resigned to that; I'm hoping that automake-1.6 may ease
> some of the problems; does it ?

Not sure. I think it still does the non-writable srcdir and the
uninstall check.
 
> 	This is indeed odd; perhaps it's a gpp related problem, I suspect that
> perhaps the IDL is not being pre-processed correctly; if you can touch
> an IDL file that is not building correctly, and then run gpp with the
> same cflags; and post the output - it'd be most helpful.
> 

Attached, though it does not look broken offhand.

Havoc

# 1 "../idl/Bonobo.idl"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "../idl/Bonobo.idl"
# 21 "../idl/Bonobo.idl"
# 1 "../idl/Bonobo_Unknown.idl" 1
# 26 "../idl/Bonobo_Unknown.idl"
module Bonobo {
        interface Unknown {





                void ref ();






                void unref ();
# 50 "../idl/Bonobo_Unknown.idl"
                Unknown queryInterface (in string repoid);
        };
};
# 22 "../idl/Bonobo.idl" 2
# 1 "../idl/Bonobo_GenericFactory.idl" 1
# 20 "../idl/Bonobo_GenericFactory.idl"
# 1 "../idl/Bonobo_Activation_types.idl" 1
# 19 "../idl/Bonobo_Activation_types.idl"
module Bonobo {
        typedef sequence<string> StringList;

        exception GeneralError {
                string description;
        };

        module Activation {
                exception NotListed {};
                exception AlreadyListed {};
                exception IncompleteContext {};
                exception ParseFailed {
                        string description;
                };
        };

        typedef string ImplementationID;
        typedef string ActivationID;

        typedef long ActivationFlags;
        const ActivationFlags ACTIVATION_FLAG_NO_LOCAL = 1<<0;
        const ActivationFlags ACTIVATION_FLAG_PRIVATE = 1<<1;
        const ActivationFlags ACTIVATION_FLAG_EXISTING_ONLY = 1<<2;

        struct ActivationEnvValue {
                string name;
                string value;
                boolean unset;
        };

        typedef sequence<ActivationEnvValue> ActivationEnvironment;


        enum ActivationResultType {
                ACTIVATION_RESULT_OBJECT,
                ACTIVATION_RESULT_SHLIB,
                ACTIVATION_RESULT_NONE
        };

        union ActivationResultData switch (ActivationResultType) {
        case ACTIVATION_RESULT_OBJECT:
                Object res_object;
        case ACTIVATION_RESULT_SHLIB:
                Bonobo::StringList res_shlib;
        };

        struct ActivationResult {
                string aid;
                ActivationResultData res;
        };


        enum ActivationPropertyType {
                ACTIVATION_P_STRING,
                ACTIVATION_P_NUMBER,
                ACTIVATION_P_BOOLEAN,
                ACTIVATION_P_STRINGV
        };

        union ActivationPropertyValue switch (ActivationPropertyType) {
        case ACTIVATION_P_STRING:
                string value_string;
        case ACTIVATION_P_NUMBER:
                double value_number;
        case ACTIVATION_P_BOOLEAN:
                boolean value_boolean;
        case ACTIVATION_P_STRINGV:
                Bonobo::StringList value_stringv;
        };

        struct ActivationProperty {
                string name;
                ActivationPropertyValue v;
        };


        struct ServerInfo {
                ImplementationID iid;

                string server_type;
                string location_info;
                string username, hostname, domain;

                sequence<ActivationProperty> props;
        };

        typedef sequence<ServerInfo> ServerInfoList;

        enum RegistrationResult {
                ACTIVATION_REG_SUCCESS,
                ACTIVATION_REG_NOT_LISTED,
                ACTIVATION_REG_ALREADY_ACTIVE,
                ACTIVATION_REG_ERROR
        };
};
# 21 "../idl/Bonobo_GenericFactory.idl" 2

module Bonobo {
        interface GenericFactory : Bonobo::Unknown {
                exception CannotActivate { };
# 36 "../idl/Bonobo_GenericFactory.idl"
                Object createObject (in string iid)
                        raises (CannotActivate);

        };
};
# 23 "../idl/Bonobo.idl" 2


# 1 "../idl/Bonobo_Exception.idl" 1
# 13 "../idl/Bonobo_Exception.idl"
module Bonobo {

        exception NotSupported {};
        exception NotImplemented {};
        exception IOError {};
        exception BadArg {};

};
# 26 "../idl/Bonobo.idl" 2
# 1 "../idl/Bonobo_Moniker.idl" 1
# 17 "../idl/Bonobo_Moniker.idl"
module Bonobo {

        typedef long ResolveFlag;
        const ResolveFlag MONIKER_ALLOW_USER_INTERACTION = 1;

        struct ResolveOptions {
                ResolveFlag flags;
                long timeout;
        };

        interface Moniker : Bonobo::Unknown {
                exception InterfaceNotFound {};
                exception TimeOut {};
                exception InvalidSyntax {};
                exception UnknownPrefix {};






                Moniker getParent ();







                void setParent (in Moniker parent);






                string getName ()
                        raises (InvalidSyntax);
# 63 "../idl/Bonobo_Moniker.idl"
                void setName (in string name)
                        raises (InvalidSyntax, UnknownPrefix);
# 74 "../idl/Bonobo_Moniker.idl"
                Unknown resolve (in ResolveOptions options,
                                            in string requestedInterface)
                        raises (InterfaceNotFound,
                                TimeOut,
                                GeneralError);
# 88 "../idl/Bonobo_Moniker.idl"
                long equal (in string name);

                void unImplemented1 ();
                void unImplemented2 ();
        };

        interface MonikerExtender : Bonobo::Unknown {
# 107 "../idl/Bonobo_Moniker.idl"
                Unknown resolve (in Moniker m,
                                 in ResolveOptions options,
                                 in string name,
                                 in string requestedInterface)
                        raises (Moniker::InterfaceNotFound,
                                Moniker::TimeOut,
                                GeneralError);

                void unImplemented1 ();
                void unImplemented2 ();
                void unImplemented3 ();
                void unImplemented4 ();
        };
};
# 27 "../idl/Bonobo.idl" 2
# 1 "../idl/Bonobo_Context.idl" 1
# 13 "../idl/Bonobo_Context.idl"
# 1 "../idl/Bonobo_Storage.idl" 1
# 24 "../idl/Bonobo_Storage.idl"
module Bonobo {

        typedef long StorageInfoFields;
        const StorageInfoFields FIELD_CONTENT_TYPE = 1;
        const StorageInfoFields FIELD_SIZE = 2;
        const StorageInfoFields FIELD_TYPE = 4;

        typedef string ContentType;

        enum StorageType {
                STORAGE_TYPE_REGULAR,
                STORAGE_TYPE_DIRECTORY
        };

        struct StorageInfo {
                string name;
                StorageType type;
                ContentType content_type;
                long size;
        };

        interface Stream : Unknown {
                typedef sequence<octet> iobuf;

                exception NoPermission {};
                exception NotSupported {};
                exception IOError {};

                enum SeekType {
                        SeekSet,
                        SeekCur,
                        SeekEnd
                };
# 65 "../idl/Bonobo_Storage.idl"
                StorageInfo getInfo (in StorageInfoFields mask)
                        raises (IOError, NoPermission, NotSupported);







                void setInfo (in StorageInfo info, in StorageInfoFields mask)
                        raises (IOError, NoPermission, NotSupported);






                void read (in long count, out iobuf buffer)
                        raises (NoPermission, IOError);







                void write (in iobuf buffer)
                        raises (NoPermission, IOError);
# 101 "../idl/Bonobo_Storage.idl"
                long seek (in long offset, in SeekType whence)
                        raises (IOError, NotSupported);







                void truncate (in long length)
                        raises (IOError, NoPermission, NotSupported);






                void commit ()
                        raises (IOError, NoPermission, NotSupported);






                void revert ()
                        raises (IOError, NoPermission, NotSupported);

                void unImplemented1 ();
                void unImplemented2 ();
        };

        interface Storage : Unknown {

                typedef sequence<StorageInfo> DirectoryList;

                typedef long OpenMode;
                const OpenMode READ = 1;
                const OpenMode WRITE = 2;
                const OpenMode CREATE = 4;
                const OpenMode FAILIFEXIST = 8;
                const OpenMode COMPRESSED = 16;
                const OpenMode TRANSACTED = 32;

                exception IOError {};
                exception NameExists {};
                exception NotFound {};
                exception NoPermission {};
                exception NotSupported {};
                exception NotStream {};
                exception NotStorage {};
                exception NotEmpty {};
# 162 "../idl/Bonobo_Storage.idl"
                StorageInfo getInfo (in string path,
                                     in StorageInfoFields mask)
                        raises (IOError, NoPermission, NotFound, NotSupported);
# 173 "../idl/Bonobo_Storage.idl"
                void setInfo (in string path, in StorageInfo info,
                              in StorageInfoFields mask)
                        raises (IOError, NoPermission, NotFound, NotSupported);
# 184 "../idl/Bonobo_Storage.idl"
                Stream openStream (in string path, in OpenMode mode)
                        raises (IOError, NotFound, NoPermission,
                                NotStream, NameExists);
# 195 "../idl/Bonobo_Storage.idl"
                Storage openStorage (in string path, in OpenMode mode)
                        raises (IOError, NotFound, NoPermission,
                                NotStorage, NameExists);







                void copyTo (in Storage target)
                        raises (IOError, NoPermission);
# 216 "../idl/Bonobo_Storage.idl"
                DirectoryList listContents (in string path,
                                            in StorageInfoFields mask)
                        raises (IOError, NotStorage, NotFound, NotSupported);
# 227 "../idl/Bonobo_Storage.idl"
                void erase (in string path)
                       raises (IOError, NoPermission, NotFound, NotEmpty);
# 237 "../idl/Bonobo_Storage.idl"
                void rename (in string path_name, in string new_path_name)
                        raises (IOError, NameExists, NotFound, NoPermission);
# 247 "../idl/Bonobo_Storage.idl"
                void commit ()
                        raises (IOError, NoPermission, NotSupported);






                void revert ()
                        raises (IOError, NoPermission, NotSupported);

                void unImplemented1 ();
                void unImplemented2 ();
        };
};
# 14 "../idl/Bonobo_Context.idl" 2


module Bonobo {

        interface MonikerContext : Unknown {







                Unknown getObject (in string name,
                                          in string repoId);







                Moniker createFromName (in string name);
# 46 "../idl/Bonobo_Context.idl"
                MonikerExtender getExtender (in string monikerPrefix,
                                             in string interfaceId);

                void unImplemented1 ();
                void unImplemented2 ();
                void unImplemented3 ();
                void unImplemented4 ();
                void unImplemented5 ();
                void unImplemented6 ();
        };







        interface RunningContext : Unknown {






                void addObject (in Object obj);







                void removeObject (in Object obj);







                void addKey (in string key);







                void removeKey (in string key);

                void atExitUnref (in Object obj);

                void unImplemented1 ();
                void unImplemented2 ();
        };
# 139 "../idl/Bonobo_Context.idl"
};
# 28 "../idl/Bonobo.idl" 2



# 1 "../idl/Bonobo_Persist.idl" 1
# 18 "../idl/Bonobo_Persist.idl"
module Bonobo {

        interface Persist : Unknown {
                enum Status {
                        SAVE_OK,
                        SAVE_CANCEL,
                        SAVE_FAILED
                };

                exception WrongDataType {};
                exception FileNotFound {};

                typedef string ContentType;
                typedef sequence<ContentType> ContentTypeList;
# 40 "../idl/Bonobo_Persist.idl"
                ContentTypeList getContentTypes ();

                typedef string IID;







                IID getIId ();






                boolean isDirty ();

                void unImplemented1 ();
                void unImplemented2 ();
        };
# 70 "../idl/Bonobo_Persist.idl"
        interface PersistFile : Persist {

                exception NoCurrentName {
                        string extension;
                };
# 83 "../idl/Bonobo_Persist.idl"
                void load (in string uri)
                        raises (IOError, NotSupported,
                                WrongDataType, FileNotFound);







                void save (in string uri)
                        raises (IOError, NotSupported);






                string getCurrentFile ()
                        raises (NoCurrentName);

                void unImplemented3 ();
                void unImplemented4 ();
        };







        interface PersistStorage : Persist {
# 123 "../idl/Bonobo_Persist.idl"
                void load (in Bonobo::Storage storage)
                        raises (IOError, NotSupported,
                                WrongDataType);
# 136 "../idl/Bonobo_Persist.idl"
                void save (in Bonobo::Storage storage,
                           in boolean same_as_loaded)
                        raises (IOError, NotSupported);
        };
# 150 "../idl/Bonobo_Persist.idl"
        interface PersistStream : Persist {
# 160 "../idl/Bonobo_Persist.idl"
                void load (in Bonobo::Stream stream, in ContentType type)
                        raises (IOError, NotSupported,
                                WrongDataType);
# 177 "../idl/Bonobo_Persist.idl"
                void save (in Bonobo::Stream stream, in ContentType type)
                        raises (IOError, NotSupported,
                                WrongDataType);

                void unImplemented3 ();
                void unImplemented4 ();
        };
};
# 32 "../idl/Bonobo.idl" 2


# 1 "../idl/Bonobo_Listener.idl" 1
# 16 "../idl/Bonobo_Listener.idl"
module Bonobo {

        interface Listener : Bonobo::Unknown {
# 27 "../idl/Bonobo_Listener.idl"
                oneway void event (in string event_name, in any args);

                void unImplemented ();
                void unImplemented2 ();
        };

        interface EventSource : Bonobo::Unknown {
                exception UnknownListener {};
# 43 "../idl/Bonobo_Listener.idl"
                void addListener (in Listener l);
# 56 "../idl/Bonobo_Listener.idl"
                void addListenerWithMask (in Listener l,
                                          in string event_mask);







                void removeListener (in Listener l)
                        raises (UnknownListener);

                void unImplemented ();
                void unImplemented2 ();
        };
};
# 35 "../idl/Bonobo.idl" 2
# 1 "../idl/Bonobo_Gdk.idl" 1
# 13 "../idl/Bonobo_Gdk.idl"
module Bonobo {

module Gdk {





        enum EventType {
                FOCUS,
                KEY,
                MOTION,
                BUTTON,
                CROSSING
        };

        enum ButtonType {
                BUTTON_PRESS,
                BUTTON_2_PRESS,
                BUTTON_3_PRESS,
                BUTTON_RELEASE
        };

        enum KeyType {
                KEY_PRESS,
                KEY_RELEASE
        };

        enum CrossType {
                ENTER, LEAVE
        };

        enum CrossMode {
                NORMAL,
                GRAB,
                UNGRAB
        };

        typedef long Time;

        struct MotionEvent {
                Gdk::Time time;
                double x, y, x_root, y_root;
                double pressure;
                double xtilt, ytilt;
                long state;
                boolean is_hint;
        };

        struct ButtonEvent {
                ButtonType type;
                Gdk::Time time;

                double x, y, x_root, y_root;

                short button;
        };

        struct KeyEvent {
                KeyType type;
                Gdk::Time time;
                short state;
                short keyval;
                short length;
                string str;
        };

        struct CrossingEvent {
                CrossType type;
                Gdk::Time time;
                double x, y, x_root, y_root;
                CrossMode mode;
                boolean focus;
                short state;
        };

        struct FocusEvent {
                boolean inside;
        };




        union Event switch (EventType) {
                case Gdk::FOCUS: FocusEvent focus;
                case Gdk::KEY: KeyEvent key;
                case Gdk::MOTION: MotionEvent motion;
                case Gdk::BUTTON: ButtonEvent button;
                case Gdk::CROSSING: CrossingEvent crossing;
        };
# 111 "../idl/Bonobo_Gdk.idl"
        typedef string WindowId;
};

module Gtk {
        struct Requisition {
                long width;
                long height;
        };
        enum State {
                StateNormal,
                StateActive,
                StatePrelight,
                StateSelected,
                StateInsensitive
        };
        enum Direction {
                DirectionTabForward,
                DirectionTabBackward,
                DirectionUp,
                DirectionDown,
                DirectionLeft,
                DirectionRight
        };
};

};
# 36 "../idl/Bonobo.idl" 2
# 1 "../idl/Bonobo_UI.idl" 1
# 15 "../idl/Bonobo_UI.idl"
module Bonobo {
        interface UIContainer;

        interface UIComponent : Bonobo::Unknown {

                void setContainer (in UIContainer container);
                void unsetContainer ();

                readonly attribute string name;

                enum EventType {
                        STATE_CHANGED,
                        OTHER
                };




                string describeVerbs ();




                oneway void execVerb (in string cname);




                oneway void uiEvent (in string id,
                                           in EventType type,
                                           in string state);






                void unImplemented ();
                void unImplemented2 ();
                void unImplemented3 ();
                void unImplemented4 ();
        };

        interface UIContainer : Bonobo::Unknown {
                exception MalformedXML {};
                exception InvalidPath {};
                exception NonExistentAttr {};
                exception Insensitive {};
                exception Unknown {};


                void registerComponent (in string component_name,
                                              in Bonobo::UIComponent component);

                oneway void deregisterComponent (in string component_name);

                oneway void freeze ();
                oneway void thaw ();

                oneway void setAttr (in string path,
                                             in string attr,
                                             in string value,
                                             in string component_name);
                string getAttr (in string path, in string attr)
                        raises (InvalidPath, NonExistentAttr);

                void setNode (in string path, in string xml,
                                             in string component_name)
                        raises (MalformedXML, InvalidPath);

                string getNode (in string path,
                                             in boolean nodeOnly)
                        raises (InvalidPath);

                void removeNode (in string path,
                                             in string by_component_name)
                        raises (InvalidPath);

                boolean exists (in string path);

                void execVerb (in string cname)
                        raises (Insensitive, Unknown);

                void uiEvent (in string id,
                                             in UIComponent::EventType type,
                                             in string state)
                        raises (Insensitive, Unknown);
# 112 "../idl/Bonobo_UI.idl"
                void setObject (in string path,
                                             in Bonobo::Unknown control)
                        raises (InvalidPath);

                Bonobo::Unknown getObject (in string path)
                        raises (InvalidPath);






                void unImplemented ();
                void unImplemented2 ();
                void unImplemented3 ();
                void unImplemented4 ();
        };
};
# 37 "../idl/Bonobo.idl" 2
# 1 "../idl/Bonobo_Property.idl" 1
# 30 "../idl/Bonobo_Property.idl"
module Bonobo {

struct Pair {
        string name;
        any value;
};

typedef sequence<Pair> PropertySet;

typedef sequence<string> KeyList;

typedef long PropertyFlags;
const PropertyFlags PROPERTY_READABLE = 1;
const PropertyFlags PROPERTY_WRITEABLE = 2;
const PropertyFlags PROPERTY_NO_LISTENING = 4;
const PropertyFlags PROPERTY_NO_AUTONOTIFY = 8;
const PropertyFlags PROPERTY_NO_PERSIST = 16;

interface PropertyBag : Bonobo::Unknown {

        exception NotFound {};
        exception InvalidType {};
        exception ReadOnly {};
        exception BackendFailed {};






        KeyList getKeys (in string filter)
                raises (NotFound, BackendFailed);
# 71 "../idl/Bonobo_Property.idl"
        CORBA::TypeCode getType (in string key)

                raises (NotFound, BackendFailed);







        any getValue (in string key)
                raises (NotFound, BackendFailed);






        void setValue (in string key, in any value)
                raises (NotFound, InvalidType, ReadOnly, BackendFailed);







        PropertySet getValues (in string filter)
                raises (NotFound, BackendFailed);






        void setValues (in PropertySet set)
                raises (InvalidType, ReadOnly, BackendFailed);
# 118 "../idl/Bonobo_Property.idl"
        any getDefault (in string key)
                raises (NotFound, BackendFailed);






        string getDocTitle (in string key)
                raises (NotFound, BackendFailed);






        string getDoc (in string key)
                raises (NotFound, BackendFailed);






        PropertyFlags getFlags (in string key)
                raises (NotFound, BackendFailed);

        void unImplemented1 ();
        void unImplemented2 ();
        void unImplemented3 ();
        void unImplemented4 ();
};

interface ConfigDatabase : PropertyBag {

        enum DBFlags {
                DEFAULT,
                WRITE,
                MANDATORY
        };






        readonly attribute boolean isWriteable;






        KeyList getDirs (in string dir)
                raises (NotFound, BackendFailed);






        boolean hasDir (in string dir)
                raises (BackendFailed);






        void removeValue (in string key)
                raises (BackendFailed);






        void removeDir (in string dir)
                raises (BackendFailed);






        void addDatabase (in ConfigDatabase db, in string key,
                                     in DBFlags flags)
                raises (BackendFailed);






        void sync ()
                raises (BackendFailed);

        void unImplemented5 ();
        void unImplemented6 ();
        void unImplemented7 ();
        void unImplemented8 ();
};

};
# 38 "../idl/Bonobo.idl" 2
# 1 "../idl/Bonobo_Control.idl" 1
# 18 "../idl/Bonobo_Control.idl"
module Bonobo {

interface ControlFrame : Bonobo::Unknown {







        Gdk::WindowId getToplevelId ();







        PropertyBag getAmbientProperties ();






        UIContainer getUIContainer ();
# 52 "../idl/Bonobo_Control.idl"
        oneway void notifyActivated (in boolean state);
# 62 "../idl/Bonobo_Control.idl"
        oneway void queueResize ();
# 75 "../idl/Bonobo_Control.idl"
        oneway void activateURI (in string uri, in boolean relative);
# 84 "../idl/Bonobo_Control.idl"
        Unknown getParentAccessible ();






        void unImplemented ();
        void unImplemented2 ();
};

interface Control : Bonobo::Unknown {
        exception NoContents { };






        PropertyBag getProperties ();






        Gtk::Requisition getDesiredSize ();






        Bonobo::Unknown getAccessible ();
# 126 "../idl/Bonobo_Control.idl"
        Gdk::WindowId getWindowId (in string cookie)
                raises (NoContents);






        UIContainer getPopupContainer ();
# 144 "../idl/Bonobo_Control.idl"
        oneway void setFrame (in ControlFrame frame);
# 153 "../idl/Bonobo_Control.idl"
        oneway void setSize (in short width, in short height);







        oneway void setState (in Gtk::State state);






        oneway void activate (in boolean activate);
# 177 "../idl/Bonobo_Control.idl"
        boolean focus (in Gtk::Direction direction);






        void unImplemented ();
        void unImplemented2 ();
        void unImplemented3 ();
};

interface PropertyControl : Bonobo::Unknown {

        readonly attribute long pageCount;

        enum Action {
                APPLY,
                HELP
        };





        exception NoPage {};
# 221 "../idl/Bonobo_Control.idl"
        Control getControl (in long pagenumber)
                raises (NoPage);
# 231 "../idl/Bonobo_Control.idl"
        void notifyAction (in long pagenumber, in Action action)
                raises (NoPage);

        void unImplemented ();
        void unImplemented2 ();
};

};
# 39 "../idl/Bonobo.idl" 2
# 1 "../idl/Bonobo_Zoomable.idl" 1
# 30 "../idl/Bonobo_Zoomable.idl"
module Bonobo {

typedef float ZoomLevel;
typedef string ZoomLevelName;

typedef sequence<ZoomLevel> ZoomLevelList;
typedef sequence<ZoomLevelName> ZoomLevelNameList;






interface ZoomableFrame : ::Bonobo::Unknown {
# 52 "../idl/Bonobo_Zoomable.idl"
        oneway void onLevelChanged (in float zoom_level);
# 61 "../idl/Bonobo_Zoomable.idl"
        oneway void onParametersChanged ();

        void unImplemented1 ();
        void unImplemented2 ();
        void unImplemented3 ();
        void unImplemented4 ();
};

interface Zoomable : Bonobo::Unknown {






        readonly attribute float level;


        readonly attribute float minLevel;
        readonly attribute float maxLevel;
        readonly attribute boolean hasMinLevel;
        readonly attribute boolean hasMaxLevel;
        readonly attribute boolean isContinuous;
        readonly attribute ZoomLevelList preferredLevels;
        readonly attribute ZoomLevelNameList preferredLevelNames;







        oneway void zoomIn ();
        oneway void zoomOut ();
        oneway void zoomFit ();
        oneway void zoomDefault ();
# 108 "../idl/Bonobo_Zoomable.idl"
        void setLevel (in float zoom_level);







        void setFrame (in ZoomableFrame zoomable_frame);

        void unImplemented1 ();
        void unImplemented2 ();
        void unImplemented3 ();
        void unImplemented4 ();
};
};
# 40 "../idl/Bonobo.idl" 2


# 1 "../idl/Bonobo_ItemContainer.idl" 1
# 15 "../idl/Bonobo_ItemContainer.idl"
module Bonobo {

        interface ItemContainer : Unknown {
                typedef sequence<string> ObjectNames;






                ObjectNames enumObjects ();







                exception NotFound {};







                exception SyntaxError {};







                Unknown getObjectByName (in string item_name,
                                         in boolean only_if_exists)
                        raises (SyntaxError, NotFound);

                void unImplemented1 ();
                void unImplemented2 ();
                void unImplemented3 ();
                void unImplemented4 ();
        };
};
# 43 "../idl/Bonobo.idl" 2
# 1 "../idl/Bonobo_Canvas.idl" 1
# 17 "../idl/Bonobo_Canvas.idl"
module Bonobo {

module Canvas {
        typedef sequence<octet> pixbuf;
        typedef unsigned long window_id;


        typedef long int32;

        struct IRect {
                long x0, y0, x1, y1;
        };

        struct DRect {
                double x0, y0, x1, y1;
        };

        const short IS_BG = 1;
        const short IS_BUF = 2;

        typedef double affine [6];




        struct Buf {
                pixbuf rgb_buf;
                long row_stride;
                IRect rect;
                int32 bg_color;
                short flags;
        };

        struct Point {
                double x, y;
        };

        typedef sequence<Point> Points;

        struct SVPSegment {
                boolean up;
                DRect bbox;
                Canvas::Points points;
        };

        typedef sequence<SVPSegment> SVP;

        struct ArtUTA {
                short x0, y0;
                short width, height;
                sequence<int32> utiles;
        };

        struct State {
                affine item_aff;
                double pixels_per_unit;
                double canvas_scroll_x1;
                double canvas_scroll_y1;
                long zoom_xofs, zoom_yofs;
                long xoffset, yoffset;
        };

        interface Component : Bonobo::Unknown {






                ArtUTA update (in Canvas::State state,
                                in affine aff, in SVP clip_path, in long flags,
                                out double x1, out double y1, out double x2, out double y2);

                void realize (in window_id drawable);
                void unrealize ();
                void map ();
                void unmap ();

                void draw (in Canvas::State state,
                             in window_id drawable,
                             in short x, in short y,
                             in short width, in short height);
# 108 "../idl/Bonobo_Canvas.idl"
                void render (inout Canvas::Buf buf);
# 118 "../idl/Bonobo_Canvas.idl"
                boolean contains (in double x, in double y);

                void bounds (in Canvas::State state,
                             out double x1, out double x2,
                             out double y1, out double y2);

                boolean event (in Canvas::State state,
                               in Bonobo::Gdk::Event event);







                void setCanvasSize (in short x, in short y, in short width, in short height);







                void setBounds (in DRect bbox);

                void unImplemented1 ();
                void unImplemented2 ();
                void unImplemented3 ();
                void unImplemented4 ();
        };






        interface ComponentProxy {





                void requestUpdate ();
# 170 "../idl/Bonobo_Canvas.idl"
                void grabFocus (in unsigned long mask,
                                in long cursor,
                                in unsigned long time);







                void ungrabFocus (in unsigned long time);






                UIContainer getUIContainer ();

                void unImplemented1 ();
                void unImplemented2 ();
                void unImplemented3 ();
                void unImplemented4 ();
        };
};

};
# 44 "../idl/Bonobo.idl" 2
# 1 "../idl/Bonobo_Embeddable.idl" 1
# 23 "../idl/Bonobo_Embeddable.idl"
module Bonobo {

interface ControlFactory : Bonobo::Unknown {
# 36 "../idl/Bonobo_Embeddable.idl"
        Control createControl (in ControlFrame frame, in UIContainer uic);

        void unImplemented1 ();
        void unImplemented2 ();
};

interface CanvasComponentFactory : Bonobo::Unknown {
# 54 "../idl/Bonobo_Embeddable.idl"
        Canvas::Component createCanvasComponent (
                                        in boolean aa,
                                        in Canvas::ComponentProxy proxy);

        void unImplemented1 ();
        void unImplemented2 ();
};

interface Embeddable : Bonobo::Unknown {







        void unImplemented1 ();
        void unImplemented2 ();
        void unImplemented3 ();
        void unImplemented4 ();
        void unImplemented5 ();
        void unImplemented6 ();
        void unImplemented7 ();
        void unImplemented8 ();
};
};
# 45 "../idl/Bonobo.idl" 2


# 1 "../idl/Bonobo_Print.idl" 1
# 15 "../idl/Bonobo_Print.idl"
module Bonobo {

        struct PrintScissor {
                double width_first_page, width_per_page;
                double height_first_page, height_per_page;
        };

        struct PrintDimensions {
                double width, height;
        };

        interface Print : Bonobo::Unknown {
# 36 "../idl/Bonobo_Print.idl"
                Stream render (in PrintDimensions pd,
                               in PrintScissor scissor);

                void unImplemented1 ();
                void unImplemented2 ();
                void unImplemented3 ();
                void unImplemented4 ();
        };
};
# 48 "../idl/Bonobo.idl" 2


# 1 "../idl/Bonobo_Clipboard.idl" 1
# 24 "../idl/Bonobo_Clipboard.idl"
module Bonobo {

        interface Clipboard : Unknown {
# 41 "../idl/Bonobo_Clipboard.idl"
                void setClipboard (in Moniker pasting_moniker,
                                   in Moniker linking_moniker);







                Moniker paste ();







                Moniker link ();

                void unImplemented1 ();
                void unImplemented2 ();
                void unImplemented3 ();
                void unImplemented4 ();
        };

        interface ClipboardStore : Unknown {




                void fetchStream (in PersistStream source,
                                  in Moniker linking_moniker);





                void fetchStorage (in PersistStorage source,
                                   in Moniker linking_moniker);

                void unImplemented1 ();
                void unImplemented2 ();
                void unImplemented3 ();
                void unImplemented4 ();
        };
};
# 51 "../idl/Bonobo.idl" 2


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]