framework/qa/complex/dispatches/Interceptor.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18 package complex.dispatches;
  19
  20 // __________ Imports __________
  21
  22 // structs, const, ...
  23 import com.sun.star.beans.PropertyValue;
  24
  25 // exceptions
  26 import com.sun.star.frame.DispatchDescriptor;
  27 import com.sun.star.frame.XDispatch;
  28 import com.sun.star.frame.XDispatchProvider;
  29 import com.sun.star.frame.XDispatchProviderInterceptor;
  30 import com.sun.star.frame.XInterceptorInfo;
  31 import com.sun.star.frame.XStatusListener;
  32
  33 // interfaces
  34
  35
  36 // helper
  37 import com.sun.star.util.URL;
  38
  39 // __________ Implementation __________
  40
  41 /**
  42  * implements a configurable interceptor for dispatch events.
  43  */
  44 public class Interceptor implements XDispatch,
  45                                     XDispatchProviderInterceptor,
  46                                     XInterceptorInfo
  47 {
  48
  49
  50     /** contains the list of interception URL schema's (wildcards are allowed there!)
  51         supported by this interceptor. It can be set from outside.
  52         If no external URLs are set, the default "*" is used instead.
  53         That would have the same effect as if this implementation would not support the
  54         interface XInterceptorInfo !
  55      */
  56     private String[] m_lURLs4InterceptionInfo = null;
  57
  58
  59
  60     /** These URL's will be blocked by this interceptor.
  61         Can be set from outside. Every queryDispatch() for these
  62         set of URL's will be answered with an empty dispatch object!
  63         If no external URLs are set the default "*" is used instead.
  64         So every incoming URL will be blocked .-)
  65      */
  66     private String[] m_lURLs4Blocking = null;
  67
  68
  69
  70     /** Every dispatch interceptor knows it's master and slave interceptor
  71         of the dispatch chain. These values must be stupid handled .-)
  72         They have to be set and reset in case the right interface methods are called.
  73         Nothing more. It's not allowed to dispose() it.
  74         The slave can be used inside queryDispatch() to forward requests,
  75         which are not handled by this interceptor instance.
  76      */
  77     private XDispatchProvider m_xSlave  = null;
  78     private XDispatchProvider m_xMaster = null;
  79
  80
  81
  82     /** counts calls of setSlave...().
  83         So the outside API test can use this value to know if this interceptor
  84         was really added to the interceptor chain of OOo.
  85      */
  86     private int m_nRegistrationCount = 0;
  87
  88
  89
  90     /** indicates if this interceptor object is currently part of the interceptor
  91         chain of OOo. Only true if a valid slave or master dispatch is set on this
  92         instance.
  93      */
  94     private boolean m_bIsRegistered = false;
  95
  96
  97
  98
  99     /** XInterceptorInfo */
 100     public synchronized String[] getInterceptedURLs()
 101     {
 102         return impl_getURLs4InterceptionInfo();
 103     }
 104
 105
 106
 107     /** XDispatchProviderInterceptor */
 108     public synchronized XDispatchProvider getSlaveDispatchProvider()
 109     {
 110         System.out.println("Interceptor.getSlaveDispatchProvider() called");
 111         return m_xSlave;
 112     }
 113
 114
 115
 116     /** XDispatchProviderInterceptor */
 117     public synchronized XDispatchProvider getMasterDispatchProvider()
 118     {
 119         System.out.println("Interceptor.getMasterDispatchProvider() called");
 120         return m_xMaster;
 121     }
 122
 123
 124
 125     /** XDispatchProviderInterceptor */
 126     public synchronized void setSlaveDispatchProvider(XDispatchProvider xSlave)
 127     {
 128         System.out.println("Interceptor.setSlaveDispatchProvider("+xSlave+") called");
 129
 130         if (xSlave != null)
 131         {
 132             ++m_nRegistrationCount;
 133             m_bIsRegistered = true;
 134         }
 135         else
 136         {
 137             m_bIsRegistered = false;
 138         }
 139
 140         m_xSlave = xSlave;
 141     }
 142
 143
 144
 145     /** XDispatchProviderInterceptor */
 146     public synchronized void setMasterDispatchProvider(XDispatchProvider xMaster)
 147     {
 148         System.out.println("Interceptor.setMasterDispatchProvider("+xMaster+") called");
 149         m_xMaster = xMaster;
 150     }
 151
 152
 153
 154     /** XDispatchProvider
 155      */
 156     public synchronized XDispatch queryDispatch(URL aURL            ,
 157                                                                    String                sTargetFrameName,
 158                                                                    int                   nSearchFlags    )
 159     {
 160         System.out.println("Interceptor.queryDispatch('"+aURL.Complete+"', '"+sTargetFrameName+"', "+nSearchFlags+") called");
 161
 162         if (impl_isBlockedURL(aURL.Complete))
 163         {
 164             System.out.println("Interceptor.queryDispatch(): URL blocked => returns NULL");
 165             return null;
 166         }
 167
 168         if (m_xSlave != null)
 169         {
 170             System.out.println("Interceptor.queryDispatch(): ask slave ...");
 171             return m_xSlave.queryDispatch(aURL, sTargetFrameName, nSearchFlags);
 172         }
 173
 174         System.out.println("Interceptor.queryDispatch(): no idea => returns this");
 175         return this;
 176     }
 177
 178
 179
 180     /** XDispatchProvider
 181      */
 182     public XDispatch[] queryDispatches(DispatchDescriptor[] lRequests)
 183     {
 184         int i = 0;
 185         int c = lRequests.length;
 186
 187         XDispatch[] lResults = new XDispatch[c];
 188         for (i=0; i<c; ++i)
 189         {
 190             lResults[i] = queryDispatch(lRequests[i].FeatureURL ,
 191                                         lRequests[i].FrameName  ,
 192                                         lRequests[i].SearchFlags);
 193         }
 194
 195         return lResults;
 196     }
 197
 198
 199
 200     /** XDispatch
 201      */
 202     public synchronized void dispatch(URL              aURL      ,
 203                                       PropertyValue[] lArguments)
 204     {
 205         System.out.println("Interceptor.dispatch('"+aURL.Complete+"') called");
 206     }
 207
 208
 209
 210     /** XDispatch
 211      */
 212     public synchronized void addStatusListener(XStatusListener xListener,
 213                                                com.sun.star.util.URL              aURL     )
 214     {
 215         System.out.println("Interceptor.addStatusListener(..., '"+aURL.Complete+"') called");
 216     }
 217
 218
 219
 220     /** XDispatch
 221      */
 222     public synchronized void removeStatusListener(XStatusListener xListener,
 223                                                   com.sun.star.util.URL              aURL     )
 224     {
 225         System.out.println("Interceptor.removeStatusListener(..., '"+aURL.Complete+"') called");
 226     }
 227
 228
 229
 230     public synchronized int getRegistrationCount()
 231     {
 232         return m_nRegistrationCount;
 233     }
 234
 235
 236
 237     public synchronized boolean isRegistered()
 238     {
 239         return m_bIsRegistered;
 240     }
 241
 242
 243     /** set a new list of URL's, which should be blocked by this interceptor.
 244         (that's why it's necessary to call this impl-method before the interceptor
 245         is used at the OOo API!)
 246      */
 247     public synchronized void setURLs4URLs4Blocking(String[] lURLs)
 248     {
 249         m_lURLs4Blocking = lURLs;
 250     }
 251
 252
 253
 254     /** must be used internal to access the member m_lURLs4InterceptionInfo
 255         - threadsafe
 256         - and to make sure it's initialized on demand
 257      */
 258     private synchronized String[] impl_getURLs4InterceptionInfo()
 259     {
 260         if (m_lURLs4InterceptionInfo == null)
 261         {
 262             m_lURLs4InterceptionInfo    = new String[] { "*" };
 263         }
 264
 265         return m_lURLs4InterceptionInfo;
 266     }
 267
 268
 269
 270     /** must be used internal to access the member m_lURLs4Blocking
 271         - threadsafe
 272         - and to make sure it's initialized on demand
 273      */
 274     private synchronized String[] impl_getURLs4Blocking()
 275     {
 276         if (m_lURLs4Blocking == null)
 277         {
 278             m_lURLs4Blocking    = new String[] { "*" };
 279         }
 280
 281         return m_lURLs4Blocking;
 282     }
 283
 284
 285     private boolean impl_isBlockedURL(String sURL)
 286     {
 287         String[] lBlockedURLs = impl_getURLs4Blocking();
 288         int      i            = 0;
 289         int      c            = lBlockedURLs.length;
 290
 291         for (i=0; i<c; ++i)
 292         {
 293             if (impl_match(sURL, lBlockedURLs[i]))
 294             {
 295                 return true;
 296             }
 297         }
 298
 299         return false;
 300     }
 301
 302
 303
 304     private boolean impl_match(String sVal1, String sVal2)
 305     {
 306         // TODO implement wildcard match
 307         return (sVal1.equals(sVal2));
 308     }
 309 }