1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
|
/* -*- 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 INCLUDED_FRAMEWORK_INC_DISPATCH_CLOSEDISPATCHER_HXX
#define INCLUDED_FRAMEWORK_INC_DISPATCH_CLOSEDISPATCHER_HXX
#include <stdtypes.h>
#include <general.h>
#include <com/sun/star/lang/XTypeProvider.hpp>
#include <com/sun/star/frame/XFrame.hpp>
#include <com/sun/star/frame/XStatusListener.hpp>
#include <com/sun/star/frame/XNotifyingDispatch.hpp>
#include <com/sun/star/frame/XDispatchInformationProvider.hpp>
#include <com/sun/star/util/URL.hpp>
#include <com/sun/star/frame/XDispatchResultListener.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <com/sun/star/frame/DispatchResultState.hpp>
#include <memory>
#include <cppuhelper/implbase.hxx>
#include <vcl/evntpost.hxx>
#include <vcl/vclptr.hxx>
class SystemWindow;
namespace framework{
/**
@short helper to dispatch the URLs ".uno:CloseDoc"/".uno:CloseWin"/".uno:CloseFrame"
to close a frame/document or the whole application implicitly in case it was the last frame
@descr These URLs implements a special functionality to close a document or the whole frame ...
and handle the state, it was the last frame or document. Then we create the
default backing document which can be used to open new ones using the file open dialog
or some other menu entries. Or we terminate the whole application in case this backing mode should not
be used.
*/
class CloseDispatcher : public ::cppu::WeakImplHelper<
css::frame::XNotifyingDispatch, // => XDispatch
css::frame::XDispatchInformationProvider >
{
// types
private:
/** @short describe, which request must be done here.
@descr The incoming URLs {.uno:CloseDoc/CloseWin and CloseFrame
can be classified so and checked later performant.}*/
enum EOperation
{
E_CLOSE_DOC,
E_CLOSE_FRAME,
E_CLOSE_WIN
};
// member
private:
/** @short reference to an uno service manager,
which can be used to create own needed
uno resources. */
css::uno::Reference< css::uno::XComponentContext > m_xContext;
/** @short reference to the target frame, which should be
closed by this dispatch. */
css::uno::WeakReference< css::frame::XFrame > m_xCloseFrame;
/** @short used for asynchronous callbacks within the main thread.
@descr Internally we work asynchronous. Because our callis
are not aware, that her request can kill its own environment ... */
std::unique_ptr<vcl::EventPoster> m_aAsyncCallback;
/** @short used inside asynchronous callback to decide,
which operation must be executed. */
EOperation m_eOperation;
/** @short for asynchronous operations we must hold us self alive! */
css::uno::Reference< css::uno::XInterface > m_xSelfHold;
/** @short holded alive for internally asynchronous operations! */
css::uno::Reference< css::frame::XDispatchResultListener > m_xResultListener;
VclPtr<SystemWindow> m_pSysWindow;
// native interface
public:
/** @short connect a new CloseDispatcher instance to its frame.
@descr One CloseDispatcher instance is bound to onw frame only.
That makes an implementation (e.g. of listener support)
much more easier .-)
@param rxContext
an un oservice manager, which is needed to create uno resource
internally.
@param xFrame
the frame where the corresponding dispatch was started.
@param sTarget
help us to find the right target for this close operation.
*/
CloseDispatcher(const css::uno::Reference< css::uno::XComponentContext >& rxContext ,
const css::uno::Reference< css::frame::XFrame >& xFrame ,
const OUString& sTarget);
/** @short does nothing real. */
virtual ~CloseDispatcher() override;
// uno interface
public:
// XNotifyingDispatch
virtual void SAL_CALL dispatchWithNotification( const css::util::URL& aURL ,
const css::uno::Sequence< css::beans::PropertyValue >& lArguments,
const css::uno::Reference< css::frame::XDispatchResultListener >& xListener ) override;
// XDispatch
virtual void SAL_CALL dispatch ( const css::util::URL& aURL ,
const css::uno::Sequence< css::beans::PropertyValue >& lArguments) override;
virtual void SAL_CALL addStatusListener ( const css::uno::Reference< css::frame::XStatusListener >& xListener ,
const css::util::URL& aURL ) override;
virtual void SAL_CALL removeStatusListener( const css::uno::Reference< css::frame::XStatusListener >& xListener ,
const css::util::URL& aURL ) override;
// XDispatchInformationProvider
virtual css::uno::Sequence< sal_Int16 > SAL_CALL getSupportedCommandGroups ( ) override;
virtual css::uno::Sequence< css::frame::DispatchInformation > SAL_CALL getConfigurableDispatchInformation( sal_Int16 nCommandGroup ) override;
// internal helper
private:
/** @short a callback for asynchronous started operations.
@descr As already mentioned, we make internally all operations
asynchronous. Otherwise our callis kill its own environment
during they call us...
*/
DECL_LINK( impl_asyncCallback, LinkParamNone*, void );
/** @short prepare m_xCloseFrame so it should be closeable without problems.
@descr Thats needed to be sure, that the document can't disagree
later with e.g. an office termination.
The problem: Closing of documents can show UI. If the user
ignores it and open/close other documents, we can't know
which state the office has after closing of this frame.
@param bAllowSuspend
force calling of XController->suspend().
@param bCloseAllOtherViewsToo
if there are other top level frames, which
contains views to the same document then our m_xCloseFrame,
they are forced to be closed too.
We need it to implement the CLOSE_DOC semantic.
@return [boolean]
sal_True if closing was successfully.
*/
bool implts_prepareFrameForClosing(const css::uno::Reference< css::frame::XFrame >& xFrame ,
bool bAllowSuspend ,
bool bCloseAllOtherViewsToo,
bool& bControllerSuspended );
/** @short close the member m_xCloseFrame.
@descr This method does not look for any document
inside this frame. Such views must be cleared
before (e.g. by calling implts_closeView()!
Otherwise e.g. the XController->suspend()
call is not made and no UI warn the user about
losing document changes. Because the
frame is closed ....
@return [bool]
sal_True if closing was successfully.
*/
bool implts_closeFrame();
/** @short set the special BackingComponent (now StartModule)
as new component of our m_xCloseFrame.
@return [bool]
sal_True if operation was successfully.
*/
bool implts_establishBackingMode();
/** @short calls XDesktop->terminate().
@descr No office code has to be called
afterwards! Because the process is dying...
The only exception is a might be registered
listener at this instance here.
Because he should know, that such things will happen :-)
@return [bool]
sal_True if termination of the application was started ...
*/
bool implts_terminateApplication();
/** @short notify a DispatchResultListener.
@descr We check the listener reference before we use it.
So this method can be called every time!
@parama xListener
the listener, which should be notified.
Can be null!
@param nState
directly used as css::frame::DispatchResultState value.
@param aResult
not used yet really ...
*/
void implts_notifyResultListener(const css::uno::Reference< css::frame::XDispatchResultListener >& xListener,
sal_Int16 nState ,
const css::uno::Any& aResult );
/** @short try to find the right target frame where this close request
must be really done.
@descr The problem behind: closing some resources depends sometimes from the
context where its dispatched. Sometimes the start frame of the dispatch
has to be closed itself (target=_self) ... sometimes its parent frame
has to be closed - BUT(!) it means a parent frame containing a top level
window. _top can't be used then for dispatch - because it address TopFrames
not frames containg top level windows. So normally _magic (which btw does not
exists at the moment .-) ) should be used. So we interpret target=<empty>
as _magic !
@param xFrame
start point for search of right dispatch frame.
@param sTarget
give us an idea how this target frame must be searched.
*/
static css::uno::Reference< css::frame::XFrame > static_impl_searchRightTargetFrame(const css::uno::Reference< css::frame::XFrame >& xFrame ,
const OUString& sTarget);
}; // class CloseDispatcher
} // namespace framework
#endif // INCLUDED_FRAMEWORK_INC_DISPATCH_CLOSEDISPATCHER_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
