1 files changed, 120 insertions, 0 deletions
diff --git a/offapi/com/sun/star/util/XCloseListener.idl b/offapi/com/sun/star/util/XCloseListener.idl
new file mode 100644
index 000000000..6f3362a9e
--- /dev/null
+++ b/offapi/com/sun/star/util/XCloseListener.idl
@@ -0,0 +1,120 @@
+/* -*- 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_util_XCloseListener_idl__
+#define __com_sun_star_util_XCloseListener_idl__
+
+#include <com/sun/star/util/CloseVetoException.idl>
+#include <com/sun/star/lang/XEventListener.idl>
+#include <com/sun/star/lang/EventObject.idl>
+
+
+ module com {  module sun {  module star {  module util {
+
+/** makes it possible to receive events when an object
+    is called for closing
+
+    <p>
+    Such close events are broadcasted by a XCloseBroadcaster
+    if somewhere tries to close it by calling XCloseable::close().
+    Listener can:
+    <ul>
+        <li>break that by throwing CloseVetoException</li>
+        <li>or accept that by deregister himself at this broadcaster.</li>
+    </ul>
+    </p>
+
+    <p>
+    If an event com::sun::star::lang::XEventListener::disposing()
+    occurred, nobody called XCloseable::close() on listened object before.
+    Then it's not allowed to break this request - it must be accepted!
+    </p>
+
+    @see XCloseable
+    @see XCloseBroadcaster
+ */
+published interface XCloseListener: com::sun::star::lang::XEventListener
+{
+    /** is called when somewhere tries to close listened object
+
+        <p>
+        Is called before XCloseListener::notifyClosing().
+        Listener has the chance to break that by throwing a CloseVetoException.
+        This exception must be passed to the original caller of XCloseable::close()
+        without any interaction.
+        </p>
+
+        <p>
+        The parameter <var>GetsOwnership</var> regulate who has to try to close the listened object
+        again, if this listener disagree with the request by throwing the exception.
+        If it's set to `FALSE` the original caller of XCloseable::close()
+        will be the owner in every case. It's not allowed to call close() from this listener then.
+        If it's set to `TRUE` this listener will be the new owner if he throw the exception,
+        otherwise not! If his still running processes will be finished he must call close() on
+        listened object again then.
+        </p>
+
+        <p>
+        If this listener doesn't disagree with th close request it depends from his internal
+        implementation if he deregister himself at the listened object.
+        But normally this must be done in XCloseListener::notifyClosing().
+        </p>
+
+        @param Source
+            describes the source of the event (must be the listened object)
+
+        @param GetsOwnership
+            `TRUE` pass the ownership to this listener, if he throw the veto exception
+            (otherwise this parameter must be ignored!)
+            <br>
+            `FALSE` forbids to grab the ownership for the listened close object and call
+            close() on that any time.
+
+        @throws CloseVetoException
+            if listener disagree with the close request on listened object he must throw this exception
+     */
+    void queryClosing(
+        [in] com::sun::star::lang::EventObject Source,
+        [in] boolean GetsOwnership )
+            raises( CloseVetoException );
+
+    /** is called when the listened object is closed really
+
+        <p>
+        Now the listened object is closed really. Listener has to accept that;
+        should deregister himself and release all references to it.
+        It's not allowed nor possible to disagree with that by throwing any exception.
+        </p>
+
+        <p>
+        If the event com::sun::star::lang::XEventListener::disposing() occurred before
+        it must be accepted too. There exist no chance for a disagreement any more.
+        </p>
+
+        @param Source
+            describes the source of the event (must be the listened object)
+     */
+    void notifyClosing( [in] com::sun::star::lang::EventObject Source );
+};
+
+
+}; }; }; };
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */