qadevOOo/runner/util/DesktopTools.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 util;
  19
  20 import helper.ConfigHelper;
  21
  22 import java.util.ArrayList;
  23
  24 import lib.StatusException;
  25
  26 import com.sun.star.awt.Rectangle;
  27 import com.sun.star.awt.WindowDescriptor;
  28 import com.sun.star.awt.XToolkit;
  29 import com.sun.star.awt.XTopWindow;
  30 import com.sun.star.awt.XWindowPeer;
  31 import com.sun.star.beans.PropertyValue;
  32 import com.sun.star.beans.XPropertySet;
  33 import com.sun.star.container.XEnumeration;
  34 import com.sun.star.frame.XComponentLoader;
  35 import com.sun.star.frame.XDesktop;
  36 import com.sun.star.frame.XFrame;
  37 import com.sun.star.frame.XModel;
  38 import com.sun.star.lang.XComponent;
  39 import com.sun.star.lang.XMultiServiceFactory;
  40 import com.sun.star.lang.XServiceInfo;
  41 import com.sun.star.uno.UnoRuntime;
  42 import com.sun.star.uno.XInterface;
  43 import com.sun.star.util.XCloseable;
  44 import com.sun.star.util.XModifiable;
  45 import com.sun.star.view.XViewSettingsSupplier;
  46
  47 /**
  48  * contains helper methods for the Desktop
  49  */
  50 public class DesktopTools
  51 {
  52
  53     /**
  54      * Queries the XComponentLoader
  55      *
  56      * @param xMSF the MultiServiceFactory
  57      * @return the gained XComponentLoader
  58      */
  59     private static XComponentLoader getCLoader(XMultiServiceFactory xMSF)
  60     {
  61         XComponentLoader oCLoader = UnoRuntime.queryInterface(
  62                 XComponentLoader.class, createDesktop(xMSF));
  63
  64         return oCLoader;
  65     }
  66
  67     /**
  68      * Creates an Instance of the Desktop service
  69      *
  70      * @param xMSF the MultiServiceFactory
  71      * @return the gained XDesktop object
  72      */
  73     public static XDesktop createDesktop(XMultiServiceFactory xMSF)
  74     {
  75         XDesktop xDesktop;
  76
  77         try
  78         {
  79             xDesktop = UnoRuntime.queryInterface(
  80                 XDesktop.class, xMSF.createInstance("com.sun.star.comp.framework.Desktop"));
  81         }
  82         catch (com.sun.star.uno.Exception e)
  83         {
  84             throw new IllegalArgumentException("Desktop Service not available", e);
  85         }
  86
  87         return xDesktop;
  88     }
  89
  90     /**
  91      * returns a XEnumeration containing all components containing on the desktop
  92      * @param xMSF the XMultiServiceFactory
  93      * @return XEnumeration of all components on the desktop
  94      */
  95     public static XEnumeration getAllComponents(XMultiServiceFactory xMSF)
  96     {
  97         return createDesktop(xMSF).getComponents().createEnumeration();
  98     }
  99
 100
 101
 102     /**
 103      * returns the current component on the desktop
 104      * @param xMSF the XMultiServiceFactory
 105      * @return XComponent of the current component on the desktop
 106      */
 107     public static XFrame getCurrentFrame(XMultiServiceFactory xMSF)
 108     {
 109         return createDesktop(xMSF).getCurrentFrame();
 110     }
 111
 112     /**
 113      * returns an object array of all open documents
 114      * @param xMSF the MultiServiceFactory
 115      * @return returns an Array of document kinds like ["swriter"]
 116      */
 117     public static Object[] getAllOpenDocuments(XMultiServiceFactory xMSF)
 118     {
 119         ArrayList<XComponent> components = new ArrayList<XComponent>();
 120
 121         XEnumeration allComp = getAllComponents(xMSF);
 122
 123         while (allComp.hasMoreElements())
 124         {
 125             try
 126             {
 127                 XComponent xComponent = UnoRuntime.queryInterface(
 128                         XComponent.class, allComp.nextElement());
 129
 130                 if (getDocumentType(xComponent) != null)
 131                 {
 132                     components.add(xComponent);
 133                 }
 134
 135             }
 136             catch (com.sun.star.container.NoSuchElementException e)
 137             {
 138             }
 139             catch (com.sun.star.lang.WrappedTargetException e)
 140             {
 141             }
 142         }
 143         return components.toArray();
 144     }
 145
 146     /**
 147      * Returns the document type for the given XComponent of an document
 148      * @param xComponent the document to query for its type
 149      * @return possible:
 150      * <ul>
 151      * <li>swriter</li>
 152      * <li>scalc</li>
 153      * <li>sdraw</li>
 154      * <li>smath</li>
 155      * </ul>
 156      * or <CODE>null</CODE>
 157      */
 158     private static String getDocumentType(XComponent xComponent)
 159     {
 160         XServiceInfo sInfo = UnoRuntime.queryInterface(
 161                 XServiceInfo.class, xComponent);
 162
 163         if (sInfo == null)
 164         {
 165             return "";
 166         }
 167         else if (sInfo.supportsService("com.sun.star.sheet.SpreadsheetDocument"))
 168         {
 169             return "scalc";
 170         }
 171         else if (sInfo.supportsService("com.sun.star.text.TextDocument"))
 172         {
 173             return "swriter";
 174         }
 175         else if (sInfo.supportsService("com.sun.star.drawing.DrawingDocument"))
 176         {
 177             return "sdraw";
 178         }
 179         else if (sInfo.supportsService("com.sun.star.presentation.PresentationDocument"))
 180         {
 181             return "simpress";
 182         }
 183         else if (sInfo.supportsService("com.sun.star.formula.FormulaProperties"))
 184         {
 185             return "smath";
 186         }
 187         else
 188         {
 189             return null;
 190         }
 191     }
 192
 193     /**
 194      * Opens a new document of a given kind
 195      * with arguments
 196      * @return the XComponent Interface of the document
 197      * @param kind the kind of document to load.<br>
 198      * possible:
 199      * <ul>
 200      * <li>swriter</li>
 201      * <li>scalc</li>
 202      * <li>sdaw</li>
 203      * <li>smath</li>
 204      * </ul>
 205      * @param Args arguments which passed to the document to load
 206      * @param xMSF the MultiServiceFactory
 207      */
 208     public static XComponent openNewDoc(XMultiServiceFactory xMSF, String kind,
 209             PropertyValue[] Args)
 210     {
 211         XComponent oDoc = null;
 212
 213         try
 214         {
 215             oDoc = getCLoader(xMSF).loadComponentFromURL("private:factory/" + kind,
 216                     "_blank", 0, Args);
 217         }
 218         catch (com.sun.star.uno.Exception e)
 219         {
 220             throw new IllegalArgumentException("Document could not be opened", e);
 221         }
 222
 223         return oDoc;
 224     }
 225
 226     /**
 227      * loads a document of from a given url
 228      * with arguments
 229      * @return the XComponent Interface of the document
 230      * @param url the URL of the document to load.
 231      * @param Args arguments which passed to the document to load
 232      * @param xMSF the MultiServiceFactory
 233      */
 234     public static XComponent loadDoc(XMultiServiceFactory xMSF, String url,
 235             PropertyValue[] Args)
 236     {
 237         XComponent oDoc = null;
 238         if (Args == null)
 239         {
 240             Args = new PropertyValue[0];
 241         }
 242         try
 243         {
 244             oDoc = getCLoader(xMSF).loadComponentFromURL(url, "_blank", 0, Args);
 245         }
 246         catch (com.sun.star.uno.Exception e)
 247         {
 248             throw new IllegalArgumentException("Document could not be loaded", e);
 249         }
 250
 251         bringWindowToFront(oDoc);
 252         return oDoc;
 253     }
 254
 255     /**
 256      * closes a given document
 257      * @param DocumentToClose the document to close
 258      */
 259     public static void closeDoc(XInterface DocumentToClose)
 260     {
 261         if (DocumentToClose == null)
 262         {
 263             return;
 264         }
 265
 266         String kd = System.getProperty("KeepDocument");
 267         if (kd != null)
 268         {
 269             System.out.println("The property 'KeepDocument' is set and so the document won't be disposed");
 270             return;
 271         }
 272         XModifiable modified = UnoRuntime.queryInterface(XModifiable.class, DocumentToClose);
 273         XCloseable closer = UnoRuntime.queryInterface(XCloseable.class, DocumentToClose);
 274
 275         try
 276         {
 277             if (modified != null)
 278             {
 279                 modified.setModified(false);
 280             }
 281             closer.close(true);
 282         }
 283         catch (com.sun.star.util.CloseVetoException e)
 284         {
 285             System.out.println("Couldn't close document");
 286         }
 287         catch (com.sun.star.lang.DisposedException e)
 288         {
 289             System.out.println("Couldn't close document");
 290         }
 291         catch (NullPointerException e)
 292         {
 293             System.out.println("Couldn't close document");
 294         }
 295         catch (com.sun.star.beans.PropertyVetoException e)
 296         {
 297             System.out.println("Couldn't close document");
 298         }
 299     }
 300
 301     /**
 302      * Creates a floating XWindow with the size of X=500 Y=100 width=400 height=600
 303      * @param xMSF the MultiServiceFactory
 304      * @throws lib.StatusException if it is not possible to create a floating window a lib.StatusException was thrown
 305      * @return a floating XWindow
 306      */
 307     public static XWindowPeer createFloatingWindow(XMultiServiceFactory xMSF)
 308             throws StatusException
 309     {
 310         return createFloatingWindow(xMSF, 500, 100, 400, 600);
 311     }
 312
 313     /**
 314      * Creates a floating XWindow on the given position and size.
 315      * @return a floating XWindow
 316      * @param X the X-Position of the floating XWindow
 317      * @param Y the Y-Position of the floating XWindow
 318      * @param width the width of the floating XWindow
 319      * @param height the height of the floating XWindow
 320      * @param xMSF the MultiServiceFactory
 321      * @throws lib.StatusException if it is not possible to create a floating window a lib.StatusException was thrown
 322      */
 323     public static XWindowPeer createFloatingWindow(XMultiServiceFactory xMSF, int X, int Y, int width, int height)
 324             throws StatusException
 325     {
 326
 327         XInterface oObj = null;
 328
 329         try
 330         {
 331             oObj = (XInterface) xMSF.createInstance("com.sun.star.awt.Toolkit");
 332         }
 333         catch (com.sun.star.uno.Exception e)
 334         {
 335             throw new StatusException("Couldn't get toolkit", e);
 336         }
 337
 338         XToolkit tk = UnoRuntime.queryInterface(
 339                 XToolkit.class, oObj);
 340
 341         WindowDescriptor descriptor = new com.sun.star.awt.WindowDescriptor();
 342
 343         descriptor.Type = com.sun.star.awt.WindowClass.TOP;
 344         descriptor.WindowServiceName = "modelessdialog";
 345         descriptor.ParentIndex = -1;
 346
 347         Rectangle bounds = new com.sun.star.awt.Rectangle();
 348         bounds.X = X;
 349         bounds.Y = Y;
 350         bounds.Width = width;
 351         bounds.Height = height;
 352
 353         descriptor.Bounds = bounds;
 354         descriptor.WindowAttributes = (com.sun.star.awt.WindowAttribute.BORDER +
 355                 com.sun.star.awt.WindowAttribute.MOVEABLE +
 356                 com.sun.star.awt.WindowAttribute.SIZEABLE +
 357                 com.sun.star.awt.WindowAttribute.CLOSEABLE +
 358                 com.sun.star.awt.VclWindowPeerAttribute.CLIPCHILDREN);
 359
 360         XWindowPeer xWindow = null;
 361
 362         try
 363         {
 364             xWindow = tk.createWindow(descriptor);
 365         }
 366         catch (com.sun.star.lang.IllegalArgumentException e)
 367         {
 368             throw new StatusException("Could not create window", e);
 369         }
 370
 371         return xWindow;
 372
 373     }
 374
 375     /**
 376      * zoom to have a view over the hole page
 377      * @param xDoc the document to zoom
 378      */
 379     public static void zoomToEntirePage(XMultiServiceFactory xMSF, XInterface xDoc)
 380     {
 381         try
 382         {
 383             XModel xMod = UnoRuntime.queryInterface(XModel.class, xDoc);
 384             XInterface oCont = xMod.getCurrentController();
 385             XViewSettingsSupplier oVSSupp = UnoRuntime.queryInterface(XViewSettingsSupplier.class, oCont);
 386
 387             XInterface oViewSettings = oVSSupp.getViewSettings();
 388             XPropertySet oViewProp = UnoRuntime.queryInterface(XPropertySet.class, oViewSettings);
 389             oViewProp.setPropertyValue("ZoomType",
 390                     Short.valueOf(com.sun.star.view.DocumentZoomType.ENTIRE_PAGE));
 391
 392             util.utils.waitForEventIdle(xMSF);
 393         }
 394         catch (Exception e)
 395         {
 396             System.out.println("Could not zoom to entire page: " + e.toString());
 397         }
 398
 399     }
 400
 401     /**
 402      * This function docks the Navigator onto the right side of the window.</p>
 403      * Note:<P>
 404      * Since the svt.viewoptions cache the view configuration at start up
 405      * the change of the docking will be effective at a restart.
 406      * @param xMSF the XMultiServiceFactory
 407      */
 408     public static void dockNavigator(XMultiServiceFactory xMSF)
 409     {
 410         // prepare Window settings
 411         try
 412         {
 413             ConfigHelper aConfig = new ConfigHelper(xMSF,
 414                     "org.openoffice.Office.Views", false);
 415
 416             aConfig.getOrInsertGroup("Windows", "10366");
 417
 418             aConfig.updateGroupProperty(
 419                     "Windows", "10366", "WindowState", "952,180,244,349;1;0,0,0,0;");
 420
 421             aConfig.insertOrUpdateExtensibleGroupProperty(
 422                     "Windows", "10366", "UserData", "Data", "V2,V,0,AL:(5,16,0/0/244/349,244;610)");
 423
 424             // Is node "SplitWindow2" available? If not, insert it.
 425             aConfig.getOrInsertGroup("Windows", "SplitWindow2");
 426
 427             aConfig.insertOrUpdateExtensibleGroupProperty(
 428                     "Windows", "SplitWindow2", "UserData", "UserItem", "V1,2,1,0,10366");
 429
 430             aConfig.flush();
 431             aConfig = null;
 432
 433         }
 434         catch (com.sun.star.uno.Exception e)
 435         {
 436             e.printStackTrace();
 437         }
 438     }
 439
 440
 441     /**
 442      * This function brings a document to the front.<P>
 443      * NOTE: it is not possible to change the window order of your Window-Manager!!
 444      * Only the order of Office documents are changeable.
 445      * @param xModel the XModel of the document to bring to top
 446      */
 447     public static void bringWindowToFront(XModel xModel)
 448     {
 449         XTopWindow xTopWindow =
 450                 UnoRuntime.queryInterface(
 451         XTopWindow.class,
 452         xModel.getCurrentController().getFrame().getContainerWindow());
 453
 454         xTopWindow.toFront();
 455     }
 456
 457     public static void bringWindowToFront(XComponent xComponent)
 458     {
 459         XModel xModel = UnoRuntime.queryInterface(XModel.class, xComponent);
 460         if (xModel != null)
 461         {
 462             bringWindowToFront(xModel);
 463         }
 464     }
 465 }