/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#ifndef __com_sun_star_ucb_Content_idl__
#define __com_sun_star_ucb_Content_idl__

#include <com/sun/star/ucb/XContent.idl>
#include <com/sun/star/lang/XComponent.idl>
#include <com/sun/star/ucb/XCommandProcessor.idl>
#include <com/sun/star/ucb/XCommandProcessor2.idl>
#include <com/sun/star/ucb/XCommandInfoChangeNotifier.idl>
#include <com/sun/star/beans/XPropertyContainer.idl>
#include <com/sun/star/beans/XPropertySetInfoChangeNotifier.idl>
#include <com/sun/star/beans/XPropertiesChangeNotifier.idl>
#include <com/sun/star/ucb/XContentCreator.idl>
#include <com/sun/star/container/XChild.idl>

module com { module sun { module star { module ucb {

/** A Content is a service that provides access to data of a
    content provided by an implementation of the service
    ContentProvider.
*/
published service Content
{

    /** provides access to the identity and the type of the content and
        allows the registration of listeners for ContentEvents.

        <p>This interface is required.
     */
    interface com::sun::star::ucb::XContent;

    /** must be implemented to make it possible to resolve cyclic object
        references.

        <p>Those references i.e. may occur if there are listeners
        registered at the content ( the content holds the listeners ) and
        the implementation of the listener interface holds a reference on
        the content. If the content shall be released,
        com::sun::star::lang::XComponent::dispose() must
        be called at the content. The implementation of this method must call
        com::sun::star::lang::XEventListener::disposing()
        on the registered listeners and release the appropriate object
        references. At the other hand, the implementation of
        XEventListener::disposing must release its appropriate references.

        <p>This interface is required.
     */
    interface com::sun::star::lang::XComponent;

    /** enables the caller to let the content execute commands.

        <p>It is strongly recommended that any implementation supports the
        improved XCommandProcessor2 interface.</p>

        <p>Typical commands are "open", "delete", "getPropertyValues" and
        "setPropertyValues". Each content must support a set of standard
        commands and properties. Also there is a set of predefined optionally
        commands and properties. A content may define additional commands and
        properties. </p>

        <p>This interface is required.</p>

        <h3>Commands</h3>
        <h4>Mandatory commands</h4>

        <table style="border-width: 1px; border-spacing: 0px; border-style: solid; border-color: gray; border-collapse: collapse; background-color: white;" class="devdoc">
                <tr>
                    <th>Command Name</th>
                    <th>Return Type</th>
                    <th>Parameters</th>
                    <th>Description</th>
                </tr>
                <tr>
                    <td>getCommandInfo</td>
                    <td>XCommandInfo</td>
                    <td>void</td>
                    <td>This command obtains an interface which allows to query
                        information on commands supported by a content.
                    </td>
                </tr>
                <tr>
                    <td>getPropertySetInfo</td>
                    <td>com::sun::star::beans::XPropertySetInfo</td>
                    <td>void</td>
                    <td>This command obtains an interface which allows to query
                        information on properties supported by a content.
                    </td>
                </tr>
                <tr>
                    <td>getPropertyValues</td>
                    <td>com::sun::star::sdbc::XRow</td>
                    <td>sequence&lt; com::sun::star::beans::Property &gt; aProps</td>
                    <td>This command obtains property values from the content.
                        <blockquote>
                            <b>Note</b>: The execution will not be aborted, if there
                            are properties requested, that are unknown to the
                            content. The returned row object must contain a NULL
                            value in the corresponding column instead.
                        </blockquote>
                    </td>
                </tr>
                <tr>
                    <td>setPropertyValues</td>
                    <td>sequence&lt; any &gt;</td>
                    <td>sequence&lt; com::sun::star::beans::PropertyValue &gt; aValues</td>
                    <td>This command sets property values of the content.
                        <p>Note that setPropertyValues does not throw an exception in the case
                        that one or more of the requested property values cannot be set.
                        The implementation should set as much property values as possible.</p>

                        <p>This command returns a sequence< any > which has exactly the same number
                        of elements like the number of properties to set. Every sequence
                        element contains the status for a property. The first sequence
                        elements corresponds to the first element in the sequence of
                        com::sun::star::beans::PropertyValue passed as
                        command argument, and so on. The exceptions will never be passed to
                        a com::sun::star::task::InteractionHandler.</p>

                        <p>Every element in the returned sequence is an any containing:</p>
                        <ul>
                            <li>No value indicates, that the property value was set successfully.</li>
                            <li>com::sun::star::beans::UnknownPropertyException
                            indicates, that the property is not known to the content
                            implementation.</li>
                            <li>com::sun::star::beans::IllegalTypeException
                            indicates, that the data type of the property value is not
                            acceptable.</li>
                            <li>com::sun::star::lang::IllegalAccessException
                            indicates, that the property is constant
                            (com::sun::star::beans::PropertyAttribute::READONLY
                            is set).</li>
                            <li>com::sun::star::lang::IllegalArgumentException
                            indicates, that the property value is not acceptable. For instance,
                            setting an empty title may be illegal.</li>
                            <li>Any other exception derived from com::sun::star::uno::Exception
                            indicates, that the value was not set successfully. For example,
                            this can be an InteractiveAugmentedIOException
                            transporting the error code IOErrorCode::ACCESS_DENIED.</li>
                        </ul>

                        <p>If the value to set is equal to the current value, no exception must
                        be added to the returned sequence</p>
                    </td>
                </tr>
        </table>

        <h4>Optional commands</h4>
        <table style="border-width: 1px; border-spacing: 0px; border-style: solid; border-color: gray; border-collapse: collapse; background-color: white;" class="devdoc">
                <tr>
                    <th>Command Name</th>
                    <th>Return Type</th>
                    <th>Parameters</th>
                    <th>Description</th>
                </tr>
                <tr>
                    <td>open</td>
                    <td>XDynamicResultSet</td>
                    <td>OpenCommandArgument2 aOpenCommandArg</td>
                    <td>
                        For <b>folder</b> objects, this command will return an
                        implementation of service DynamicResultSet.
                        <p>The OpenCommandArgument2 members must be
                        filled as follows:</p>
                        <ul>
                            <li>com::sun::star::ucb::OpenCommandArgument::Mode:
                                com::sun::star::ucb::OpenMode::ALL or
                                com::sun::star::ucb::OpenMode::FOLDERS or
                                com::sun::star::ucb::OpenMode::DOCUMENTS.
                                The implementation of the open command MUST support all these modes!
                            </li>
                            <li>com::sun::star::ucb::OpenCommandArgument::Priority:
                                can be set, but implementation may ignore the value
                            </li>
                            <li>com::sun::star::ucb::OpenCommandArgument::Sink:
                                empty( ignored )
                            </li>
                            <li>com::sun::star::ucb::OpenCommandArgument::Properties:
                                The properties for which the result set shall
                                contain the property values. The order of the
                                sequence is the same as the order of result set
                                columns. First element of sequence will be row
                                number one, second will be row number two, ...
                            </li>
                            <li>com::sun::star::ucb::OpenCommandArgument2::SortingInfo:
                                contains sort criteria, if result set shall
                                be sorted, otherwise it can be left empty.
                            </li>
                        </ul>
                        The execution must be aborted by the implementation of this command
                        (by throwing a CommandAbortedException), if an
                        unsupported mode is requested.
                    </td>
                </tr>
                <tr>
                    <td>open</td>
                    <td>void</td>
                    <td>OpenCommandArgument2 aOpenCommandArg</td>
                    <td>For non-folder objects, the OpenCommandArgument2
                        struct will be prefilled with a data sink object, which
                        will be filled with the content data.
                        <p>The OpenCommandArgument2 members must be
                        filled as follows:</p>
                        <ul>
                            <li>com::sun::star::ucb::OpenCommandArgument::Mode:
                                com::sun::star::ucb::OpenMode::DOCUMENT or
                                com::sun::star::ucb::OpenMode::DOCUMENT_SHARE_DENY_NONE or
                                com::sun::star::ucb::OpenMode::DOCUMENT_SHARE_DENY_WRITE.
                                Support for DOCUMENT is mandatory, all others are optional.
                            </li>
                            <li>com::sun::star::ucb::OpenCommandArgument::Priority:
                                can be set, but implementation may ignore the value
                            </li>
                            <li>com::sun::star::ucb::OpenCommandArgument::Sink:
                                a sink, where the implementation can put the document data into.
                            </li>
                            <li>com::sun::star::ucb::OpenCommandArgument::Properties: empty ( ignored )</li>
                            <li>com::sun::star::ucb::OpenCommandArgument2::SortingInfo: empty ( ignored )</li>
                        </ul>
                        <p>The execution must be aborted by the implementation of this command
                        (by throwing a CommandAbortedException), if an
                        unsupported mode is requested.</p>
                    </td>
                </tr>
                <tr>
                    <td>createNewContent</td>
                    <td>XContent</td>
                    <td>ContentInfo contentinfo</td>
                    <td>
                        This command creates a new <b>non-persistent</b> content of a given type.
                        <p>This command must be supported by every Content
                        that supports the property "CreatableContentsInfo", if the returned
                        property value contains a non-empty sequence of creatable types.
                        <blockquote>
                            Note: This command is part of the replacement for the deprecated
                            interface XContentCreator.
                        </blockquote>
                        <p>Creation of a new <b>persistent</b> content:
                        <ol>
                            <li>creatabletypes = obtain "CreatableContentsInfo" property from creator</li>
                            <li>choose a suitable type from creatabletypes</li>
                            <li>newObject = execute command "createNewContent(type)" at creator</li>
                            <li>initialize the new object (i.e. newObject.Property1 = ...)</li>
                            <li>execute command "insert" at new content. This command
                                commits the data and makes the new content persistent.</li>
                        </ol>
                    </td>
                </tr>
                <tr>
                    <td>insert</td>
                    <td>void</td>
                    <td>InsertCommandArgument aInsertCommandArg</td>
                    <td>
                        <ol>
                            <li>
                                This command inserts a <b>new content</b>. It commits the process of
                                creating a new content via executing the command "createNewContent"
                                and initializing it via setting properties, afterwards.<br>
                                The command is not called on the content which created the new
                                content, because the new object already knows where it is to be
                                inserted (i.e. Calling createNewContent with the content type for a
                                message on a News Group creates a content which internally belongs
                                to the Outbox. Calling "insert" on that message will result in
                                posting the article to the appropriate News Group). Not calling
                                "insert" for the new content, i.e. because the user cancels writing
                                a new message, simply discards the new object. No extra call to
                                "delete" is necessary.<br>
                                On successful completion of this command, the parent of the inserted
                                content must propagate the change by notifying a
                                ContentEvent - ContentAction::INSERTED.
                            </li>
                            <li>
                                Additionally this command can be called at any time to overwrite
                                the data of an <b>existing content</b>.
                            </li>
                        </ol>
                    </td>
                </tr>
                <tr>
                    <td>update</td>
                    <td>void</td>
                    <td>OpenCommandArgument2 aOpenCommandArg</td>
                    <td>This command triggers an update operation on a content.
                        For example, when "updating" a POP3-Inbox, the content
                        for that box will get and store all new objects on the
                        appropriate server. The inserted contents will be
                        notified by calling
                        XContentEventListener::contentEvent().
                    </td>
                </tr>
                <tr>
                    <td>synchronize</td>
                    <td>void</td>
                    <td>OpenCommandArgument2 aOpenCommandArg</td>
                    <td>
                        This command triggers a synchronization operation between locally
                        cached data and remote server's data. For example, when
                        "synchronizing" a POP3-Inbox the content for that box will get and
                        store all new objects and destroy all cached data for objects no
                        longer existing on the server. The inserted/deleted contents will
                        be notified by calling
                        XContent::contentEvent().
                    </td>
                </tr>
                <tr>
                    <td>close</td>
                    <td>void</td>
                    <td>void</td>
                    <td>This command closes an object.</td>
                </tr>
                <tr>
                    <td>delete</td>
                    <td>void</td>
                    <td>boolean bDeletePhysically</td>
                    <td>
                        This command deletes an object. If `TRUE` is passed as parameter,
                        the object will be destroyed physically. Otherwise it will be put
                        into trash can, if such a service is available and the object to
                        be deleted supports the command "undelete".
                        On successful completion of this command, the deleted content
                        must propagate its deletion by notifying a ContentEvent
                        - ContentAction::DELETED. Additionally, the contents
                        parent must notify a ContentEvent
                        - ContentAction::REMOVED
                    </td>
                </tr>
                <tr>
                    <td>undelete</td>
                    <td>void</td>
                    <td>void</td>
                    <td>
                        This command restores an object previously deleted into trash. It
                        must be supported by objects which claim to be undeletable, but
                        should never be called directly.
                    </td>
                </tr>
                <tr>
                    <td>search</td>
                    <td>XDynamicResultSet</td>
                    <td>SearchCommandArgument aSearchCommandArg</td>
                    <td>
                        This command searches for subcontents of a content matching the
                        given search criteria. The command will return an implementation
                        of service DynamicResultSet.
                    </td>
                </tr>
                <tr>
                    <td>transfer</td>
                    <td>void</td>
                    <td>TransferInfo aTransferInfo</td>
                    <td>
                        <blockquote>
                            <b>Important note:</b> A client that wants to transfer data should
                            not execute this command, but it should execute the command
                            "globalTransfer" at the UniversalContentBroker.
                            This command is able to transfer all kind of content
                            supported by that UCB.
                        </blockquote>
                        This command transfers (copies/moves) an object from one location
                        to another. It must be executed at the folder content representing
                        the <b>destination</b> of the transfer operation.<br>
                        Note that the implementation need not be able to handle
                        any type of contents.<br>
                        Generally, there are good chances that a transfer of a content will
                        succeed, if source and target folder have the same URL scheme.
                        But there is no guaranty for that.<br>
                        For instance, moving a message from a folder on IMAP server A
                        to a folder on IMAP server B may fail, because the transfer
                        command can't be implemented efficiently for this scenario,
                        because it is not directly supported by the IMAP protocol.
                        On the other hand, moving a message from one folder to
                        another folder on the same IMAP server should work, because it can
                        be implemented efficiently.<br>
                        If an implementation is not able to handle a given source URL,
                        it should indicate this by issuing a
                        InteractiveBadTransferURLException interaction request.<br>
                        Source and target folder may be the same when doing a move operation.
                        <br>
                        Transfers without the transfer command can be done as follows:
                        <ol>
                            <li>Create a new content at the target folder<br>
                            <code>targetContent = target.execute( "createNewContent", type )</code>
                            </li>
                            <li>Transfer data from source to target content<br>
                            <code>props = sourceContent.execute( "getPropertyValues", ... )</code>
                            <code>dataStream = sourceContent.execute( "open", ... )</code>
                            <code>targetContent.execute( "setPropertyValues", props )</code>
                            </li>
                            <li>Insert ( commit ) the new content<br>
                            <code>targetContent.execute( "insert", dataStream )</code>
                            </li>
                            <li>For move operations only: destroy the source content<br>
                            <code>sourceContent.execute( "delete", ... )</code>
                            </li>
                        </ol>
                        <p>This mechanism should work for all transfer operations, but generally
                        it's less efficient than the transfer command.</p>
                    </td>
                </tr>
                <tr>
                    <td>lock</td>
                    <td>void</td>
                    <td>void</td>
                    <td>
                        This command obtains an exclusive write lock for the resource. The
                        lock is active until command "unlock" is executed, or the OOo
                        session that obtained the lock ends, or until the lock is released by
                        a third party (e.g. a system administrator).<br>
                        Exceptions:
                        <ul>
                            <li>InteractiveLockingLockedException</li>
                            <li>InteractiveLockingLockExpiredException</li>
                        </ul>
                    </td>
                </tr>
                <tr>
                    <td>unlock</td>
                    <td>void</td>
                    <td>void</td>
                    <td>
                        This command removes a lock obtained by executing the command "lock"
                        from the resource.<br>
                        <p>Exceptions:
                        <ul>
                            <li>InteractiveLockingLockedException</li>
                            <li>InteractiveLockingLockExpiredException</li>
                        </ul>
                        </p>
                        <p>Note that InteractiveLockingLockExpiredException might
                        be raised by any command that requires a previously obtained lock.
                        </p>
                    </td>
                </tr>
                <tr>
                    <td>addProperty</td>
                    <td>void</td>
                    <td>PropertyCommandArgument aCmdArg</td>
                    <td>
                        Adds a new properties to the content.
                        <p>
                            PropertyCommandArgument::Property
                            contains information about the property to be added.
                            PropertyCommandArgument::DefaultValue
                            may contain the default value for the property. Its type must
                            match the one specified in com::sun::star::beans::Property::Type.
                        </p>
                        <p>Note that the dynamic properties must be kept persistent. The
                        service Store (UCB persistence service) may be used to
                        implement this.</p>
                        <p><b>Important:</b> The implementation must at least support
                        adding properties of the following basic data types:</p>
                        <p>
                            <ul>
                                <li>boolean
                                <li>char
                                <li>byte
                                <li>string
                                <li>short
                                <li>long
                                <li>hyper
                                <li>float
                                <li>double
                            </ul>
                        </p>
                        <p>
                            Raises a ::com::sun::star::beans::PropertyExistException
                            if a property with the same name already exists;
                           ::com::sun::star::beans::IllegalTypeException
                           if the property has an unsupported type;
                           ::com::sun::star::lang::IllegalArgumentException
                           if the Name of the property is empty.</p>
                        <blockquote>
                            Note: This command is new since Apache OpenOffice 4.0, LibreOffice 4.2 and replaces the deprecated interface method
                            com::sun::star::beans::XPropertyContainer::addProperty.
                        </blockquote>
                    </td>
                </tr>
                <tr>
                    <td>removeProperty</td>
                    <td>void</td>
                    <td>string PropertyName</td>
                    <td>Removes the properties from the content.
                        <p>Raises a ::com::sun::star::beans::UnknownPropertyException
                        if the property does not exist;
                        ::com::sun::star::beans::NotRemoveableException
                        if the property is not removable.</p>
                        <blockquote>
                            Note: This command is new since Apache OpenOffice 4.0, LibreOffice 4.2 and replaces the deprecated interface method
                            com::sun::star::beans::XPropertyContainer::removeProperty.
                        </blockquote>
                    </td>
                </tr>
        </table>

        <h3>Properties</h3>
        <h4>Mandatory properties</h4>

        <table style="border-width: 1px; border-spacing: 0px; border-style: solid; border-color: gray; border-collapse: collapse; background-color: white;" class="devdoc">
                <tr>
                    <th>Name</th>
                    <th>Type</th>
                    <th>Description</th>
                </tr>
                <tr>
                    <td>ContentType</td>
                    <td>string</td>
                    <td>
                        contains a unique type string for the content
                        ( i.e. "application/vnd.sun.star.hierarchy-link" ).
                        <p>This property is always read-only.</p>
                        <p>The ContentType should not be confused with the MIME
                        media type ( MIME types ) of the content. Media types
                        may be provided through the optional property "MediaType".</p>
                        <p>The value of this property should match the information on creatable
                        contents given by UCB contents that implement the property
                        "CreatableContentsInfo".</p>
                    </td>
                </tr>
                <tr>
                    <td>IsFolder</td>
                    <td>boolean</td>
                    <td>indicates, whether a content can contain other contents.</td>
                </tr>
                <tr>
                    <td>IsDocument</td>
                    <td>boolean</td>
                    <td>indicates, whether a content is a document. This means,
                        the content can dump itself into a data sink.
                    </td>
                </tr>
                <tr>
                    <td>Title</td>
                    <td>string</td>
                    <td>contains the title of an object (e.g. the subject of a message).</td>
                </tr>
        </table>

        <h4>Optional properties</h4>

        <table style="border-width: 1px; border-spacing: 0px; border-style: solid; border-color: gray; border-collapse: collapse; background-color: white;" class="devdoc">
                <tr>
                    <th>Name</th>
                    <th>Type</th>
                    <th>Description</th>
                </tr>
                <tr>
                    <td>AutoUpdateInterval</td>
                    <td>long</td>
                    <td>contains the interval for automatic updates of an object.
                        It is specified in seconds.
                    </td>
                </tr>
                <tr>
                    <td>ConnectionLimit</td>
                    <td>short</td>
                    <td>contains the maximum number of network connections
                        allowed for one (internet) protocol at a time. (e.g. The HTTP
                        cache can be configured to use a maximum for the number of
                        connections used for browsing.)
                    </td>
                </tr>
                <tr>
                    <td>ConnectionMode</td>
                    <td>short</td>
                    <td>contains the current connection mode for the object.
                        (see ConnectionMode)
                    </td>
                </tr>
                <tr>
                    <td>CreatableContentsInfo</td>
                    <td>sequence ContentInfo</td>
                    <td>
                        contains the types of Contents a Content object can create via
                        command "createNewContent".
                        <p>If the property value can be a non-empty sequence, the
                        Content must also support command "createNewContent".</p>
                        <blockquote>
                            Note: This property is part of the replacement for the deprecated
                            interface XContentCreator.
                        </blockquote>
                    </td>
                </tr>
                <tr>
                    <td>DateCreated</td>
                    <td>com::sun::star::util::DateTime</td>
                    <td>contains the date and time the object was created.</td>
                </tr>
                <tr>
                    <td>DateModified</td>
                    <td>com::sun::star::util::DateTime</td>
                    <td>contains the date and time the object was last modified.</td>
                </tr>
                <tr>
                    <td>DocumentCount</td>
                    <td>long</td>
                    <td>contains the count of documents of a folder.</td>
                </tr>
                <tr>
                    <td>DocumentCountMarked</td>
                    <td>long</td>
                    <td>contains the count of marked documents within a folder.</td>
                </tr>
                <tr>
                    <td>DocumentHeader</td>
                    <td>sequence&lt; DocumentHeaderField &gt; </td>
                    <td>contains a sequence of document header fields (i.e. header
                        fields of a MIME-message, or the document info of an
                        office document ). For some standard header fields there
                        are predefined separate properties, like &quot;MessageTo&quot;.
                    </td>
                </tr>
                <tr>
                    <td>DocumentStoreMode</td>
                    <td>DocumentStoreMode</td>
                    <td>contains information about the way a folder stores the
                        contents of (remote) documents.
                    </td>
                </tr>
                <tr>
                    <td>FolderCount</td>
                    <td>long</td>
                    <td>contains the count of subfolders of a folder.</td>
                </tr>
                <tr>
                    <td>FreeSpace</td>
                    <td>hyper</td>
                    <td>contains the free space left on a storage device. It is
                        specified in bytes.</td>
                </tr>
                <tr>
                    <td>HasDocuments</td>
                    <td>boolean</td>
                    <td>indicates whether a content has subcontents, which are documents.</td>
                </tr>
                <tr>
                    <td>HasFolders</td>
                    <td>boolean</td>
                    <td>indicates whether a content has subcontents, which are folders.</td>
                </tr>
                <tr>
                    <td>IsMarked</td>
                    <td>boolean</td>
                    <td>indicates whether a content is &quot;marked&quot;.</td>
                </tr>
                <tr>
                    <td>IsRead</td>
                    <td>boolean</td>
                    <td>indicates whether a content has been "read".</td>
                </tr>
                <tr>
                    <td>IsReadOnly</td>
                    <td>boolean</td>
                    <td>indicates whether a content is read-only.</td>
                </tr>
                <tr>
                    <td>IsSubscribed</td>
                    <td>boolean</td>
                    <td>indicates whether a content is subscribed.</td>
                </tr>
                <tr>
                    <td>IsTimeLimitedStore</td>
                    <td>boolean</td>
                    <td>indicates whether the feature to store contents
                        depending on their age is active.</td>
                </tr>
                <tr>
                    <td>UpdateOnOpen</td>
                    <td>boolean</td>
                    <td>indicates whether (sub)contents shall be automatically updated
                        every time a (folder) content is opened.<br>This property may be
                        used to control whether a folder content should read data only
                        from local cache when it is opened, or whether it should connect
                        to a server to obtain latest data.</td>
                </tr>
                <tr>
                    <td>Keywords</td>
                    <td>string</td>
                    <td>contains the keywords of a document (e.g. the value
                        of the &quot;keywords&quot; header field of a news article).</td>
                </tr>
                <tr>
                    <td>MediaType</td>
                    <td>string</td>
                    <td>contains the media type ( MIME type ) of a content. It is highly
                        recommended to support this property if the content's implementation
                        can obtain the media type natively from its data source ( i.e.
                        HTTP servers provide media types for all their documents ).
                    </td>
                </tr>
                <tr>
                    <td>MessageBCC</td>
                    <td>string</td>
                    <td>contains the BCC (blind carbon copy) receiver(s) of a message.</td>
                </tr>
                <tr>
                    <td>MessageCC</td>
                    <td>string</td>
                    <td>contains the CC (carbon copy) receiver(s) of a message.</td>
                </tr>
                <tr>
                    <td>MessageFrom</td>
                    <td>string</td>
                    <td>contains (the address of) the sender of a message.</td>
                </tr>
                <tr>
                    <td>MessageId</td>
                    <td>string</td>
                    <td>contains the ID of a message.</td>
                </tr>
                <tr>
                    <td>MessageInReplyTo</td>
                    <td>string</td>
                    <td>contains the &quot;In-Reply-To&quot; field of a message.</td>
                </tr>
                <tr>
                    <td>MessageReplyTo</td>
                    <td>string</td>
                    <td>contains the &quot;Reply-To&quot; field of a message.</td>
                </tr>
                <tr>
                    <td>MessageTo</td>
                    <td>string</td>
                    <td>contains the recipient(s) of a message.</td>
                </tr>
                <tr>
                    <td>NewsGroups</td>
                    <td>string</td>
                    <td>contains the name(s) of the newsgroup(s) into which a message was posted.</td>
                </tr>
                <tr>
                    <td>Password</td>
                    <td>string</td>
                    <td>contains a password (e.g. needed to access a POP3-Server).</td>
                </tr>
                <tr>
                    <td>Priority</td>
                    <td>Priority</td>
                    <td>contains a priority (i.e. of a message).</td>
                </tr>
                <tr>
                    <td>References</td>
                    <td>string</td>
                    <td>contains the &quot;References&quot; field of a news article.</td>
                </tr>
                <tr>
                    <td>Rules</td>
                    <td>RuleSet</td>
                    <td>contains the rules set for a content.</td>
                </tr>
                <tr>
                    <td>SeenCount</td>
                    <td>long</td>
                    <td>contains the count of seen/read subcontents of a folder content.</td>
                </tr>
                <tr>
                    <td>ServerBase</td>
                    <td>string</td>
                    <td>contains the base directory to use on a server. (e.g. Setting
                        the server base of an FTP-Account to &quot;/pub/incoming&quot;
                        will result in showing contents from that directory and not from
                        server's root directory)
                    </td>
                </tr>
                <tr>
                    <td>ServerName</td>
                    <td>string</td>
                    <td>contains a server name (e.g. The name of the server to use for
                        a POP3-Account).
                    </td>
                </tr>
                <tr>
                    <td>ServerPort</td>
                    <td>short</td>
                    <td>contains a numeric server port.</td>
                </tr>
                <tr>
                    <td>Size</td>
                    <td>hyper</td>
                    <td>contains the size (usually in bytes) of an object.</td>
                </tr>
                <tr>
                    <td>SizeLimit</td>
                    <td>hyper</td>
                    <td>contains a size limit for an object. (e.g. One may specify the
                        maximum size of the HTTP-Cache)
                    </td>
                </tr>
                <tr>
                    <td>SubscribedCount</td>
                    <td>long</td>
                    <td>contains the count of subscribed contents of a folder.</td>
                </tr>
                <tr>
                    <td>SynchronizePolicy</td>
                    <td>SynchronizePolicy</td>
                    <td>contains the policy to use when synchronizing two objects.</td>
                </tr>
                <tr>
                    <td>TargetFrames</td>
                    <td>string</td>
                    <td>contains information about the target frame to use when displaying
                        an object.
                        <p>The value is a string containing three tokens, separated by &quot;;&quot;
                        (A semicolon):<br/>
                            <dl>
                                <dt>1st token</dt>
                                    <dd>Behavior on &quot;select&quot; ( single click )</dd>
                                <dt>2nd token</dt>
                                    <dd>Behavior on &quot;open&quot;   ( double click )</dd>
                                <dt>3rd token</dt>
                                    <dd>Behavior on &quot;open in new task&quot; ( double click + CTRL key )</dd>
                            </dl>
                         </p>
                        <p> Each token may contain the following values:<br/>
                            <dl>
                            <dt>&quot;_beamer&quot;</dt>
                                <dd>Show in &quot;Beamer&quot;</dd>
                            <dt>&quot;_top&quot;</dt>
                                <dd>Show in current frame (replaces old)</dd>
                            <dt>&quot;_blank&quot;</dt>
                                <dd>Show in new task</dd>
                            </dl>
                        </p>
                    </td>
                </tr>
                <tr>
                    <td>TargetURL</td>
                    <td>string</td>
                    <td>for contents that are links to other contents, contains the URL of
                        the target content</td>
                </tr>
                <tr>
                    <td>TimeLimitStore</td>
                    <td>short</td>
                    <td>contains the value to use if the property "IsTimeLimitedStore" is set.</td>
                </tr>
                <tr>
                    <td>UserName</td>
                    <td>string</td>
                    <td>contains a user name. (e.g. the user name needed to access a
                        POP3-Account)</td>
                </tr>
                <tr>
                    <td>VerificationMode</td>
                    <td>VerificationMode </td>
                    <td>describes a verification policy.</td>
                </tr>
        </table>
     */
    interface com::sun::star::ucb::XCommandProcessor;


    /** is an enhanced version of XCommandProcessor that has an
        additional method for releasing command identifiers obtained via
        XCommandProcessor::createCommandIdentifier() to avoid
        resource leaks. For a detailed description of the problem refer to
        XCommandProcessor2::releaseCommandIdentifier().

        <p>Where many existing Content implementations do not
        (yet), every new implementation should support this interface.
     */
    [optional] interface com::sun::star::ucb::XCommandProcessor2;

    /** notifies changes of property values to listeners registered for
        those properties.

        <p>This interface is required.
     */
    interface com::sun::star::beans::XPropertiesChangeNotifier;

    /** can be used to add new properties to the content and to remove
        properties from the content dynamically.

        <p>Note that the dynamic properties must be kept persistent. The
        service Store (UCB persistence service) may be used to
        implement this.

        <p><b>Important:</b> The implementation of
        com::sun::star::beans::XPropertyContainer::addProperty()
        must at least support adding properties of the following basic data
        types:

        <p>
            <ul>
                <li>boolean
                <li>char
                <li>byte
                <li>string
                <li>short
                <li>long
                <li>hyper
                <li>float
                <li>double
            </ul>
        </p>

        <p>If a property with an unsupported type shall be added a
        com::sun::star::beans::IllegalTypeException must
        be raised.

        @deprecated
            <p>This interface is <b>deprecated</b>, because a
            ContentProvider might need a
            XCommandEnvironment to perform the tasks of adding and
            removing properties. New implementations should implement the
            respective commands "addProperty" and "removeProperty" instead.
     */
    interface com::sun::star::beans::XPropertyContainer;

    /** can be used to notify properties removed from or added to the
        content's property set.

        <p>This interface must be implemented, if the implementation can
        dynamically change it's property set ( e.g. because it implements
        the interface
        com::sun::star::beans::XPropertyContainer. )
     */
    [optional] interface com::sun::star::beans::XPropertySetInfoChangeNotifier;

    /** can be used to notify commands removed from or added to the
        content's command set.

        <p>This interface must be implemented, if the implementation can
        dynamically change it's command set ( e.g. because the set of
        available commands depends on the value of a property of the
        content ).

        <p>This interface is optional.
     */
    [optional] interface com::sun::star::ucb::XCommandInfoChangeNotifier;

    /** creates new contents (i.e. creates a new folder in another folder
        somewhere in the local file system).

        <p>A content is "new", if it does not physically exist before creating
        it using this interface.

        <p>This interface is optional. It should be implemented by contents
        which shall be able to create new objects.

        @deprecated

        <p>This interface is <b>deprecated</b>. Use property
        "CreatableContentsInfo" and command "createNewContent" instead.
     */
    [optional] interface com::sun::star::ucb::XContentCreator;

    /** provides access to the parent content of this content.

        <p>The object returned by the implementation of the method
        com::sun::star::container::XChild::getParent()
        must implement the service Content. If the content is a
        root object, an empty interface may be returned.

        <p>This interface must be implemented by a content which is a (logical)
        child of a content.
     */
    [optional] interface com::sun::star::container::XChild;
};


}; }; }; };

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */