1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // __________ Imports __________
25 
26 import com.sun.star.uno.UnoRuntime;
27 
28 import java.lang.*;
29 import javax.swing.*;
30 import java.util.Vector;
31 
32 // __________ Implementation __________
33 
34 /**
35  * This class can be used to intercept dispatched URL's
36  * on any frame used in this demo application.
37  * It intercept all URL's which try to create a new empty frame.
38  * (e.g. "private:factory/swriter")
39  * Nobody can guarantee that this interception will be really used -
40  * because another interceptor (registered at a later time then this one!)
41  * will be called before this one.
42  * Implementation is executed inside a new thread to prevent application
43  * against possible deadlocks. This deadlocks can occure if
44  * synchronous/asynchronous ... normal ones and oneway calls are mixed.
45  * Notifications of listener will be oneway mostly - her reactions can
46  * be synchronous then. => deadlocks are possible
47  *
48  * @author     Andreas Schlüns
49  * @created    06.03.2002 09:38
50  */
51 public class Interceptor implements com.sun.star.frame.XFrameActionListener,
52                                     com.sun.star.frame.XDispatchProviderInterceptor,
53                                     com.sun.star.frame.XDispatchProvider,
54                                     com.sun.star.frame.XDispatch,
55                                     com.sun.star.frame.XInterceptorInfo,
56                                     IShutdownListener,
57                                     IOnewayLink
58 {
59     // ____________________
60 
61     /**
62      * const
63      * All these URL's are intercepted by this implementation.
64      */
65     private static final String[] INTERCEPTED_URLS = { "private:factory/*" ,
66                                                        ".uno:SaveAs"       ,
67                                                        "slot:5300"         ,
68                                                        ".uno:Quit"         };
69 
70     // ____________________
71 
72     /**
73      * @member m_xMaster     use this interceptor if he doesn't handle queried dispatch request
74      * @member m_xSlave      we can forward all unhandled requests to this slave interceptor
75      * @member m_xFrame      intercepted frame
76      * @member m_bDead       there exist more then one way to finish an object of this class - we must know it sometimes
77      */
78     private com.sun.star.frame.XDispatchProvider m_xMaster            ;
79     private com.sun.star.frame.XDispatchProvider m_xSlave             ;
80     private com.sun.star.frame.XFrame            m_xFrame             ;
81     private boolean                              m_bIsActionListener  ;
82     private boolean                              m_bIsRegistered      ;
83     private boolean                              m_bDead              ;
84 
85     // ____________________
86 
87     /**
88      * ctor
89      * Initialize the new interceptor. Given frame reference can be used to
90      * register this interceptor on it automatically later.
91      *
92      * @seealso startListening()
93      *
94      * @param xFrame
95      *          this interceptor will register himself at this frame to intercept dispatched URLs
96      */
97     Interceptor(/*IN*/ com.sun.star.frame.XFrame xFrame)
98     {
99         m_xFrame            = xFrame ;
100         m_xSlave            = null   ;
101         m_xMaster           = null   ;
102         m_bIsRegistered     = false  ;
103         m_bIsActionListener = false  ;
104         m_bDead             = false  ;
105     }
106 
107     //_____________________
108 
109     /**
110      * start working as frame action listener really.
111      * We will be frame action listener here. In case
112      * we get a frame action which indicates, that we should
113      * update our interception. Because such using of an interecptor
114      * isn't guaranteed - in case a newer one was registered ...
115      */
116     public void startListening()
117     {
118         com.sun.star.frame.XFrame xFrame = null;
119         synchronized(this)
120         {
121             if (m_bDead)
122                 return;
123             if (m_xFrame==null)
124                 return;
125             if (m_bIsActionListener==true)
126                 return;
127             xFrame = m_xFrame;
128         }
129         m_xFrame.addFrameActionListener(this);
130         synchronized(this)
131         {
132             m_bIsActionListener=true;
133         }
134     }
135 
136     //_____________________
137 
138     /**
139      * In case we got an oneway listener callback - we had to use the office
140      * asynchronous then. This method is the callback from the started thread
141      * (started inside the original oneway method). We found all parameters of
142      * the original request packed inside a vector. Here we unpack it and
143      * call the right internal helper method, which implements the right
144      * funtionality.
145      *
146      * @seealso frameAction()
147      * @seealso dispatch()
148      *
149      * @param nRequest
150      *          indicates, which was the original request (identifies the
151      *          original called method)
152      *
153      * @param lParams
154      *          the vector with all packed parameters of the original request
155      */
156     public void execOneway(/*IN*/ int nRequest,/*IN*/ Vector lParams )
157     {
158         synchronized(this)
159         {
160             if (m_bDead)
161                 return;
162         }
163 
164         // was it frameAction()?
165         if (nRequest==OnewayExecutor.REQUEST_FRAMEACTION)
166         {
167             com.sun.star.frame.FrameActionEvent[] lOutAction   = new com.sun.star.frame.FrameActionEvent[1];
168             Vector[]                              lInParams    = new Vector[1];
169                                                   lInParams[0] = lParams;
170 
171             OnewayExecutor.codeFrameAction( OnewayExecutor.DECODE_PARAMS ,
172                                             lInParams                    ,
173                                             lOutAction                   );
174             impl_frameAction(lOutAction[0]);
175         }
176         else
177         // was it dispatch()?
178         if (nRequest==OnewayExecutor.REQUEST_DISPATCH)
179         {
180             com.sun.star.util.URL[]              lOutURL      = new com.sun.star.util.URL[1];
181             com.sun.star.beans.PropertyValue[][] lOutProps    = new com.sun.star.beans.PropertyValue[1][];
182             Vector[]                             lInParams    = new Vector[1];
183                                                  lInParams[0] = lParams;
184 
185             OnewayExecutor.codeDispatch( OnewayExecutor.DECODE_PARAMS ,
186                                          lInParams                    ,
187                                          lOutURL                      ,
188                                          lOutProps                    );
189             impl_dispatch(lOutURL[0],lOutProps[0]);
190         }
191     }
192 
193     // ____________________
194 
195     /**
196      * call back for frame action events
197      * We use it to update our interception. Because if a new component was loaded into
198      * the frame or another interceptor was registered, we should refresh our connection
199      * to the frame. Otherwhise we can't guarantee full functionality here.
200      *
201      * Note: Don't react synchronous in an asynchronous listener callback. So use a thread
202      * here to update anything.
203      *
204      * @seealso impl_frameAction()
205      *
206      * @param aEvent
207      *          describes the action
208      */
209     public /*ONEWAY*/  void frameAction(/*IN*/ com.sun.star.frame.FrameActionEvent aEvent)
210     {
211         synchronized(this)
212         {
213             if (m_bDead)
214                 return;
215         }
216 
217         boolean bHandle = false;
218         switch(aEvent.Action.getValue())
219         {
220             case com.sun.star.frame.FrameAction.COMPONENT_ATTACHED_value   : bHandle=true; break;
221             case com.sun.star.frame.FrameAction.COMPONENT_DETACHING_value  : bHandle=true; break;
222             case com.sun.star.frame.FrameAction.COMPONENT_REATTACHED_value : bHandle=true; break;
223             // Don't react for CONTEXT_CHANGED here. Ok it indicates, that may another interceptor
224             // was registered at the frame ... but if we register ourself there - we get a context
225             // changed too :-( Best way to produce a never ending recursion ...
226             // May be that somewhere find a safe mechanism to detect own produced frame action events
227             // and ignore it.
228             case com.sun.star.frame.FrameAction.CONTEXT_CHANGED_value :
229                     System.out.println("Time to update interception ... but may it will start a recursion. So I let it :-(");
230                     bHandle=false;
231                     break;
232         }
233 
234         // ignore some events
235         if (! bHandle)
236             return;
237 
238         // pack the event and start thread - which call us back later
239         Vector[]                              lOutParams   = new Vector[1];
240         com.sun.star.frame.FrameActionEvent[] lInAction    = new com.sun.star.frame.FrameActionEvent[1];
241                                               lInAction[0] = aEvent;
242 
243         OnewayExecutor.codeFrameAction( OnewayExecutor.ENCODE_PARAMS ,
244                                         lOutParams                   ,
245                                         lInAction                    );
246         OnewayExecutor aExecutor = new OnewayExecutor( (IOnewayLink)this                  ,
247                                                        OnewayExecutor.REQUEST_FRAMEACTION ,
248                                                        lOutParams[0]                      );
249         aExecutor.start();
250     }
251 
252     // ____________________
253 
254     /**
255      * Indicates using of us as an interceptor.
256      * Now we have to react for the requests, we are registered.
257      * That means: load new empty documents - triggered by the new menu of the office.
258      * Because it's oneway - use thread for loading!
259      *
260      * @seealso impl_dispatch()
261      *
262      * @param aURL
263      *          describes the document, which should be loaded
264      *
265      * @param lArguments
266      *          optional parameters for loading
267      */
268     public /*ONEWAY*/ void dispatch(/*IN*/ com.sun.star.util.URL aURL,/*IN*/ com.sun.star.beans.PropertyValue[] lArguments)
269     {
270         synchronized(this)
271         {
272             if (m_bDead)
273                 return;
274         }
275 
276         Vector[]                             lOutParams      = new Vector[1];
277         com.sun.star.util.URL[]              lInURL          = new com.sun.star.util.URL[1];
278         com.sun.star.beans.PropertyValue[][] lInArguments    = new com.sun.star.beans.PropertyValue[1][];
279                                              lInURL[0]       = aURL      ;
280                                              lInArguments[0] = lArguments;
281 
282         OnewayExecutor.codeDispatch( OnewayExecutor.ENCODE_PARAMS ,
283                                      lOutParams                   ,
284                                      lInURL                       ,
285                                      lInArguments                 );
286         OnewayExecutor aExecutor = new OnewayExecutor( (IOnewayLink)this               ,
287                                                        OnewayExecutor.REQUEST_DISPATCH ,
288                                                        lOutParams[0]                   );
289         aExecutor.start();
290     }
291 
292 
293     //_____________________
294 
295     /**
296      * Internal call back for frame action events, triggered by the used
297      * OnewayExecutor thread we started in frameAction().
298      * We use it to update our interception on the internal saved frame.
299      *
300      * @param aEvent
301      *          describes the action
302      */
303     public void impl_frameAction(/*IN*/ com.sun.star.frame.FrameActionEvent aEvent)
304     {
305         synchronized(this)
306         {
307             if (m_bDead)
308                 return;
309         }
310 
311         // deregistration will be done every time ...
312         // But may it's not necessary to establish a new registration!
313         // Don't look for ignoring actions - it was done already inside original frameAction() call!
314         boolean bRegister = false;
315 
316         // analyze the event and decide which reaction is useful
317         switch(aEvent.Action.getValue())
318         {
319             case com.sun.star.frame.FrameAction.COMPONENT_ATTACHED_value   : bRegister = true ; break;
320             case com.sun.star.frame.FrameAction.COMPONENT_REATTACHED_value : bRegister = true ; break;
321             case com.sun.star.frame.FrameAction.COMPONENT_DETACHING_value  : bRegister = false; break;
322         }
323 
324         com.sun.star.frame.XFrame xFrame        = null ;
325         boolean                   bIsRegistered = false;
326         synchronized(this)
327         {
328             bIsRegistered   = m_bIsRegistered;
329             m_bIsRegistered = false;
330             xFrame          = m_xFrame;
331         }
332 
333         com.sun.star.frame.XDispatchProviderInterception xRegistration = (com.sun.star.frame.XDispatchProviderInterception)UnoRuntime.queryInterface(
334             com.sun.star.frame.XDispatchProviderInterception.class,
335             xFrame);
336 
337         if(xRegistration==null)
338             return;
339 
340         if (bIsRegistered)
341             xRegistration.releaseDispatchProviderInterceptor(this);
342 
343         if (! bRegister)
344             return;
345 
346         xRegistration.registerDispatchProviderInterceptor(this);
347         synchronized(this)
348         {
349             m_bIsRegistered = true;
350         }
351     }
352 
353     // ____________________
354 
355     /**
356      * Implementation of interface XDispatchProviderInterceptor
357      * These functions are used to build a list of interceptor objects
358      * connected in both ways.
359      * Searching for a right interceptor is made by forwarding any request
360      * from toppest master to lowest slave of this hierarchy.
361      * If an interceptor whish to handle the request he can break that
362      * and return himself as a dispatcher.
363      */
364     public com.sun.star.frame.XDispatchProvider getSlaveDispatchProvider()
365     {
366         synchronized(this)
367         {
368             return m_xSlave;
369         }
370     }
371 
372     // ____________________
373 
374     public void setSlaveDispatchProvider(com.sun.star.frame.XDispatchProvider xSlave)
375     {
376         synchronized(this)
377         {
378             m_xSlave = xSlave;
379         }
380     }
381 
382     // ____________________
383 
384     public com.sun.star.frame.XDispatchProvider getMasterDispatchProvider()
385     {
386         synchronized(this)
387         {
388             return m_xMaster;
389         }
390     }
391 
392     // ____________________
393 
394     public void setMasterDispatchProvider(com.sun.star.frame.XDispatchProvider xMaster)
395     {
396         synchronized(this)
397         {
398             m_xMaster = xMaster;
399         }
400     }
401 
402     // ____________________
403 
404     /**
405      * Implementation of interface XDispatchProvider
406      * These functions are called from our master if he willn't handle the outstanding request.
407      * Given parameter should be checked if they are right for us. If it's true, the returned
408      * dispatcher should be this implementation himself; otherwise call should be forwarded
409      * to the slave.
410      *
411      * @param aURL
412      *          describes the request, which should be handled
413      *
414      * @param sTarget
415      *          specifies the target frame for this request
416      *
417      * @param nSearchFlags
418      *          optional search flags, if sTarget isn't a special one
419      *
420      * @return [XDispatch]
421      *          a dispatch object, which can handle the given URL
422      *          May be NULL!
423      */
424     public com.sun.star.frame.XDispatch queryDispatch(/*IN*/ com.sun.star.util.URL aURL,/*IN*/ String sTarget,/*IN*/ int nSearchFlags)
425     {
426         synchronized(this)
427         {
428             if (m_bDead)
429                 return null;
430         }
431 
432         // intercept loading empty documents into new created frames
433         if(
434             (sTarget.compareTo       ("_blank"         ) == 0   ) &&
435             (aURL.Complete.startsWith("private:factory") == true)
436           )
437         {
438             System.out.println("intercept private:factory");
439             return this;
440         }
441 
442         // intercept opening the SaveAs dialog
443         if (aURL.Complete.startsWith(".uno:SaveAs") == true)
444         {
445             System.out.println("intercept SaveAs by returning null!");
446             return null;
447         }
448 
449         // intercept "File->Exit" inside the menu
450         if (
451             (aURL.Complete.startsWith("slot:5300") == true)  ||
452             (aURL.Complete.startsWith(".uno:Quit") == true)
453            )
454         {
455             System.out.println("intercept File->Exit");
456             return this;
457         }
458 
459         synchronized(this)
460         {
461             if (m_xSlave!=null)
462                 return m_xSlave.queryDispatch(aURL, sTarget, nSearchFlags);
463         }
464 
465         return null;
466     }
467 
468     // ____________________
469 
470     public com.sun.star.frame.XDispatch[] queryDispatches(/*IN*/ com.sun.star.frame.DispatchDescriptor[] lDescriptor)
471     {
472         synchronized(this)
473         {
474             if (m_bDead)
475                 return null;
476         }
477         // Resolve any request seperatly by using own "dispatch()" method.
478         // Note: Don't pack return list if "null" objects occure!
479         int                            nCount      = lDescriptor.length;
480         com.sun.star.frame.XDispatch[] lDispatcher = new com.sun.star.frame.XDispatch[nCount];
481         for(int i=0; i<nCount; ++i)
482         {
483             lDispatcher[i] = queryDispatch(lDescriptor[i].FeatureURL ,
484                                            lDescriptor[i].FrameName  ,
485                                            lDescriptor[i].SearchFlags);
486         }
487         return lDispatcher;
488     }
489 
490     // ____________________
491 
492     /**
493      * This method is called if this interceptor "wins the request".
494      * We intercepted creation of new frames and loading of empty documents.
495      * Do it now.
496      *
497      * @param aURL
498      *          describes the document
499      *
500      * @param lArguments
501      *          optional arguments for loading
502      */
503     public void impl_dispatch(/*IN*/ com.sun.star.util.URL aURL,/*IN*/ com.sun.star.beans.PropertyValue[] lArguments)
504     {
505         synchronized(this)
506         {
507             if (m_bDead)
508                 return;
509         }
510 
511         if (
512             (aURL.Complete.startsWith("slot:5300") == true) ||
513             (aURL.Complete.startsWith(".uno:Quit") == true)
514            )
515         {
516             System.exit(0);
517         }
518         else
519         if (aURL.Complete.startsWith("private:factory") == true)
520         {
521             // Create view frame for showing loaded documents on demand.
522             // The visible state is necessary for JNI functionality to get the HWND and plug office
523             // inside a java window hierarchy!
524             DocumentView aNewView = new DocumentView();
525             aNewView.setVisible(true);
526             aNewView.createFrame();
527             aNewView.load(aURL.Complete,lArguments);
528         }
529     }
530 
531     // ____________________
532 
533     /**
534      * Notification of status listener isn't guaranteed (instead of listener on XNotifyingDispatch interface).
535      * So this interceptor doesn't support that really ...
536      */
537     public /*ONEWAY*/ void addStatusListener(/*IN*/ com.sun.star.frame.XStatusListener xListener,/*IN*/ com.sun.star.util.URL aURL)
538     {
539 /*        if (aURL.Complete.startsWith(".uno:SaveAs")==true)
540         {
541             com.sun.star.frame.FeatureStateEvent aEvent = new com.sun.star.frame.FeatureStateEvent(
542                                                                 this,
543                                                                 aURL,
544                                                                 "",
545                                                                 false,
546                                                                 false,
547                                                                 null);
548             if (xListener!=null)
549             {
550                 System.out.println("interceptor disable SavAs by listener notify");
551                 xListener.statusChanged(aEvent);
552             }
553         }*/
554     }
555 
556     // ____________________
557 
558     public /*ONEWAY*/ void removeStatusListener(/*IN*/ com.sun.star.frame.XStatusListener xListener,/*IN*/ com.sun.star.util.URL aURL)
559     {
560     }
561 
562     // ____________________
563 
564     /**
565      * Implements (optional!) optimization for interceptor mechanism.
566      * Any interceptor which provides this special interface is called automatically
567      * at registration time on this method. Returned URL's will be used to
568      * call this interceptor directly without calling his masters before, IF(!)
569      * following rules will be true:
570      *      (1) every master supports this optional interface too
571      *      (2) nobody of these masters whish to intercept same URL then this one
572      * This interceptor whish to intercept creation of new documents.
573      */
574     public String[] getInterceptedURLs()
575     {
576         return INTERCEPTED_URLS;
577     }
578 
579     // ____________________
580 
581     /**
582      * This class listen on the intercepted frame to free all used ressources on closing.
583      * We forget the reference to the frame only here. Deregistration
584      * isn't necessary here - because this frame dies and wish to forgoten.
585      *
586      * @param aSource
587      *          must be our internal saved frame, on which we listen for frame action events
588      */
589     public /*ONEAY*/ void disposing(/*IN*/ com.sun.star.lang.EventObject aSource)
590     {
591         synchronized(this)
592         {
593             if (m_bDead)
594                 return;
595             if (m_xFrame!=null && UnoRuntime.areSame(aSource.Source,m_xFrame))
596             {
597                 m_bIsActionListener = false;
598                 m_xFrame            = null ;
599             }
600         }
601         shutdown();
602     }
603 
604     // ____________________
605 
606     /**
607      * If this java application shutdown - we must cancel all current existing
608      * listener connections. Otherwhise the office will run into some
609      * DisposedExceptions if it tries to use these forgotten listener references.
610      * And of course it can die doing that.
611      * We are registered at a central object to be informed if the VM will exit.
612      * So we can react.
613      */
614     public void shutdown()
615     {
616         com.sun.star.frame.XFrame xFrame            = null ;
617         boolean                   bIsRegistered     = false;
618         boolean                   bIsActionListener = false;
619         synchronized(this)
620         {
621             // don't react a second time here!
622             if (m_bDead)
623                 return;
624             m_bDead = true;
625 
626             bIsRegistered       = m_bIsRegistered;
627             m_bIsRegistered     = false;
628 
629             bIsActionListener   = m_bIsActionListener;
630             m_bIsActionListener = false;
631 
632             xFrame              = m_xFrame;
633             m_xFrame            = null;
634         }
635 
636         // it's a good idead to cancel listening for frame action events
637         // before(!) we deregister us as an interceptor.
638         // Because registration and deregistratio nof interceptor objects
639         // will force sending of frame action events ...!
640         if (bIsActionListener)
641             xFrame.removeFrameActionListener(this);
642 
643         if (bIsRegistered)
644         {
645             com.sun.star.frame.XDispatchProviderInterception xRegistration = (com.sun.star.frame.XDispatchProviderInterception)UnoRuntime.queryInterface(
646                 com.sun.star.frame.XDispatchProviderInterception.class,
647                 xFrame);
648 
649             if(xRegistration!=null)
650                 xRegistration.releaseDispatchProviderInterceptor(this);
651         }
652 
653         xFrame = null;
654 
655         synchronized(this)
656         {
657             m_xMaster = null;
658             m_xSlave  = null;
659         }
660     }
661 }
662