ucb/source/ucp/tdoc/tdoc_contentcaps.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 /**************************************************************************
  22                                 TODO
  23  **************************************************************************
  24
  25  **************************************************************************
  26
  27     Props/Commands:
  28
  29                         root  document folder  folder  stream  stream
  30                                                 (new)          (new)
  31     ----------------------------------------------------------------
  32     ContentType         r       r       r       r       r       r
  33     IsDocument          r       r       r       r       r       r
  34     IsFolder            r       r       r       r       r       r
  35     Title               r       r       w       w       w       w
  36     CreatableContentsInfo r     r       r       r       r       r
  37     Storage             -       -       r       r       -       -
  38     DocumentModel       -       r       -       -       -       -
  39
  40     getCommandInfo      x       x       x       x       x       x
  41     getPropertySetInfo  x       x       x       x       x       x
  42     getPropertyValues   x       x       x       x       x       x
  43     setPropertyValues   x       x       x       x       x       x
  44     insert              -       -       x       x       x(*)    x(*)
  45     delete              -       -       x       -       x       -
  46     open                x       x       x       -       x       -
  47     transfer            -       x       x       -       -       -
  48     createNewContent    -       x       x       -       -       -
  49
  50 #ifdef NO_STREAM_CREATION_WITHIN_DOCUMENT_ROOT
  51  (*) not supported by streams that are direct children of document
  52 #endif
  53
  54  *************************************************************************/
  55
  56 #include <com/sun/star/beans/Property.hpp>
  57 #include <com/sun/star/beans/PropertyAttribute.hpp>
  58 #include <com/sun/star/beans/PropertyValue.hpp>
  59 #include <com/sun/star/embed/XStorage.hpp>
  60 #include <com/sun/star/frame/XModel.hpp>
  61 #include <com/sun/star/ucb/CommandInfo.hpp>
  62 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
  63 #include <com/sun/star/ucb/TransferInfo.hpp>
  64 #include <osl/diagnose.h>
  65 #include <sal/macros.h>
  66 #include <tdoc_content.hxx>
  67
  68 namespace com { namespace sun { namespace star { namespace embed {
  69     class XStorage;
  70 } } } }
  71
  72 using namespace com::sun::star;
  73 using namespace tdoc_ucp;
  74
  75
  76
  77 // Content implementation.
  78
  79
  80
  81 #define MAKEPROPSEQUENCE( a ) \
  82     uno::Sequence< beans::Property >( a, (sizeof (a) / sizeof (a[0])) )
  83
  84 #define MAKECMDSEQUENCE( a ) \
  85     uno::Sequence< ucb::CommandInfo >( a, (sizeof (a) / sizeof (a[0])) )
  86
  87
  88
  89 // IMPORTANT: If any property data ( name / type / ... ) are changed, then
  90 //            Content::getPropertyValues(...) must be adapted too!
  91
  92
  93
  94 // virtual
  95 uno::Sequence< beans::Property > Content::getProperties(
  96             const uno::Reference< ucb::XCommandEnvironment > & /*xEnv*/ )
  97 {
  98     osl::Guard< osl::Mutex > aGuard( m_aMutex );
  99
 100     if ( m_aProps.getType() == STREAM )
 101     {
 102
 103
 104         // Stream: Supported properties
 105
 106
 107
 108         static const beans::Property aStreamPropertyInfoTable[] =
 109         {
 110
 111             // Mandatory properties
 112
 113             beans::Property(
 114                 OUString( "ContentType" ),
 115                 -1,
 116                 cppu::UnoType<OUString>::get(),
 117                 beans::PropertyAttribute::BOUND
 118                     | beans::PropertyAttribute::READONLY
 119             ),
 120             beans::Property(
 121                 OUString( "IsDocument" ),
 122                 -1,
 123                 cppu::UnoType<bool>::get(),
 124                 beans::PropertyAttribute::BOUND
 125                     | beans::PropertyAttribute::READONLY
 126             ),
 127             beans::Property(
 128                 OUString( "IsFolder" ),
 129                 -1,
 130                 cppu::UnoType<bool>::get(),
 131                 beans::PropertyAttribute::BOUND
 132                     | beans::PropertyAttribute::READONLY
 133             ),
 134             beans::Property(
 135                 OUString( "Title" ),
 136                 -1,
 137                 cppu::UnoType<OUString>::get(),
 138                 beans::PropertyAttribute::BOUND
 139             ),
 140
 141             // Optional standard properties
 142
 143             beans::Property(
 144                 OUString(
 145                     "CreatableContentsInfo" ),
 146                 -1,
 147                 cppu::UnoType<uno::Sequence< ucb::ContentInfo >>::get(),
 148                 beans::PropertyAttribute::BOUND
 149                     | beans::PropertyAttribute::READONLY
 150             )
 151
 152             // New properties
 153
 154         };
 155         return MAKEPROPSEQUENCE( aStreamPropertyInfoTable );
 156     }
 157     else if ( m_aProps.getType() == FOLDER )
 158     {
 159
 160
 161         // Folder: Supported properties
 162
 163
 164
 165         static const beans::Property aFolderPropertyInfoTable[] =
 166         {
 167
 168             // Mandatory properties
 169
 170             beans::Property(
 171                 OUString( "ContentType" ),
 172                 -1,
 173                 cppu::UnoType<OUString>::get(),
 174                 beans::PropertyAttribute::BOUND
 175                     | beans::PropertyAttribute::READONLY
 176             ),
 177             beans::Property(
 178                 OUString( "IsDocument" ),
 179                 -1,
 180                 cppu::UnoType<bool>::get(),
 181                 beans::PropertyAttribute::BOUND
 182                     | beans::PropertyAttribute::READONLY
 183             ),
 184             beans::Property(
 185                 OUString( "IsFolder" ),
 186                 -1,
 187                 cppu::UnoType<bool>::get(),
 188                 beans::PropertyAttribute::BOUND
 189                     | beans::PropertyAttribute::READONLY
 190             ),
 191             beans::Property(
 192                 OUString( "Title" ),
 193                 -1,
 194                 cppu::UnoType<OUString>::get(),
 195                 beans::PropertyAttribute::BOUND
 196             ),
 197
 198             // Optional standard properties
 199
 200             beans::Property(
 201                 OUString(
 202                     "CreatableContentsInfo" ),
 203                 -1,
 204                 cppu::UnoType<uno::Sequence< ucb::ContentInfo >>::get(),
 205                 beans::PropertyAttribute::BOUND
 206                     | beans::PropertyAttribute::READONLY
 207             ),
 208
 209             // New properties
 210
 211             beans::Property(
 212                 OUString( "Storage" ),
 213                 -1,
 214                 cppu::UnoType<embed::XStorage>::get(),
 215                 beans::PropertyAttribute::BOUND
 216                     | beans::PropertyAttribute::READONLY
 217             )
 218         };
 219         return MAKEPROPSEQUENCE( aFolderPropertyInfoTable );
 220     }
 221     else if ( m_aProps.getType() == DOCUMENT )
 222     {
 223
 224
 225         // Document: Supported properties
 226
 227
 228
 229         static const beans::Property aDocPropertyInfoTable[] =
 230         {
 231
 232             // Mandatory properties
 233
 234             beans::Property(
 235                 OUString( "ContentType" ),
 236                 -1,
 237                 cppu::UnoType<OUString>::get(),
 238                 beans::PropertyAttribute::BOUND
 239                     | beans::PropertyAttribute::READONLY
 240             ),
 241             beans::Property(
 242                 OUString( "IsDocument" ),
 243                 -1,
 244                 cppu::UnoType<bool>::get(),
 245                 beans::PropertyAttribute::BOUND
 246                     | beans::PropertyAttribute::READONLY
 247             ),
 248             beans::Property(
 249                 OUString( "IsFolder" ),
 250                 -1,
 251                 cppu::UnoType<bool>::get(),
 252                 beans::PropertyAttribute::BOUND
 253                     | beans::PropertyAttribute::READONLY
 254             ),
 255             beans::Property(
 256                 OUString( "Title" ),
 257                 -1,
 258                 cppu::UnoType<OUString>::get(),
 259                 beans::PropertyAttribute::BOUND
 260                     | beans::PropertyAttribute::READONLY
 261             ),
 262
 263             // Optional standard properties
 264
 265             beans::Property(
 266                 OUString(
 267                     "CreatableContentsInfo" ),
 268                 -1,
 269                 cppu::UnoType<uno::Sequence< ucb::ContentInfo >>::get(),
 270                 beans::PropertyAttribute::BOUND
 271                     | beans::PropertyAttribute::READONLY
 272             ),
 273
 274             // New properties
 275
 276             beans::Property(
 277                 OUString( "DocumentModel" ),
 278                 -1,
 279                 cppu::UnoType<frame::XModel>::get(),
 280                 beans::PropertyAttribute::BOUND
 281                     | beans::PropertyAttribute::READONLY
 282             )
 283         };
 284         return MAKEPROPSEQUENCE( aDocPropertyInfoTable );
 285     }
 286     else
 287     {
 288
 289
 290         // Root: Supported properties
 291
 292
 293
 294         OSL_ENSURE( m_aProps.getType() == ROOT, "Wrong content type!" );
 295
 296         static const beans::Property aRootPropertyInfoTable[] =
 297         {
 298
 299             // Mandatory properties
 300
 301             beans::Property(
 302                 OUString( "ContentType" ),
 303                 -1,
 304                 cppu::UnoType<OUString>::get(),
 305                 beans::PropertyAttribute::BOUND
 306                     | beans::PropertyAttribute::READONLY
 307             ),
 308             beans::Property(
 309                 OUString( "IsDocument" ),
 310                 -1,
 311                 cppu::UnoType<bool>::get(),
 312                 beans::PropertyAttribute::BOUND
 313                     | beans::PropertyAttribute::READONLY
 314             ),
 315             beans::Property(
 316                 OUString( "IsFolder" ),
 317                 -1,
 318                 cppu::UnoType<bool>::get(),
 319                 beans::PropertyAttribute::BOUND
 320                     | beans::PropertyAttribute::READONLY
 321             ),
 322             beans::Property(
 323                 OUString( "Title" ),
 324                 -1,
 325                 cppu::UnoType<OUString>::get(),
 326                 beans::PropertyAttribute::BOUND
 327                     | beans::PropertyAttribute::READONLY
 328             ),
 329
 330             // Optional standard properties
 331
 332             beans::Property(
 333                 OUString(
 334                     "CreatableContentsInfo" ),
 335                 -1,
 336                 cppu::UnoType<uno::Sequence< ucb::ContentInfo >>::get(),
 337                 beans::PropertyAttribute::BOUND
 338                     | beans::PropertyAttribute::READONLY
 339             )
 340
 341             // New properties
 342
 343         };
 344         return MAKEPROPSEQUENCE( aRootPropertyInfoTable );
 345     }
 346 }
 347
 348
 349 // virtual
 350 uno::Sequence< ucb::CommandInfo > Content::getCommands(
 351             const uno::Reference< ucb::XCommandEnvironment > & /*xEnv*/ )
 352 {
 353     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 354
 355     if ( m_aProps.getType() == STREAM )
 356     {
 357 #ifdef NO_STREAM_CREATION_WITHIN_DOCUMENT_ROOT
 358         Uri aUri( m_xIdentifier->getContentIdentifier() );
 359         Uri aParentUri( aUri.getParentUri() );
 360
 361         if ( aParentUri.isDocument() )
 362         {
 363
 364
 365             // Stream, that is a child of a document: Supported commands
 366
 367
 368
 369             static const ucb::CommandInfo aStreamCommandInfoTable1[] =
 370             {
 371
 372                 // Mandatory commands
 373
 374                 ucb::CommandInfo(
 375                     OUString( "getCommandInfo" ),
 376                     -1,
 377                     cppu::UnoType<void>::get()
 378                 ),
 379                 ucb::CommandInfo(
 380                     OUString( "getPropertySetInfo" ),
 381                     -1,
 382                     cppu::UnoType<void>::get()
 383                 ),
 384                 ucb::CommandInfo(
 385                     OUString( "getPropertyValues" ),
 386                     -1,
 387                     cppu::UnoType<uno::Sequence< beans::Property >>::get()
 388                 ),
 389                 ucb::CommandInfo(
 390                     OUString( "setPropertyValues" ),
 391                     -1,
 392                     cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get()
 393                 ),
 394
 395                 // Optional standard commands
 396
 397                 ucb::CommandInfo(
 398                     OUString( "delete" ),
 399                     -1,
 400                     cppu::UnoType<bool>::get()
 401                 ),
 402                 ucb::CommandInfo(
 403                     OUString( "open" ),
 404                     -1,
 405                     cppu::UnoType<ucb::OpenCommandArgument2>::get()
 406                 )
 407
 408                 // New commands
 409
 410             };
 411             return MAKECMDSEQUENCE( aStreamCommandInfoTable1 );
 412         }
 413 #endif
 414
 415
 416         // Stream: Supported commands
 417
 418
 419
 420         static const ucb::CommandInfo aStreamCommandInfoTable[] =
 421         {
 422
 423             // Mandatory commands
 424
 425             ucb::CommandInfo(
 426                 OUString( "getCommandInfo" ),
 427                 -1,
 428                 cppu::UnoType<void>::get()
 429             ),
 430             ucb::CommandInfo(
 431                 OUString( "getPropertySetInfo" ),
 432                 -1,
 433                 cppu::UnoType<void>::get()
 434             ),
 435             ucb::CommandInfo(
 436                 OUString( "getPropertyValues" ),
 437                 -1,
 438                 cppu::UnoType< uno::Sequence< beans::Property >>::get()
 439             ),
 440             ucb::CommandInfo(
 441                 OUString( "setPropertyValues" ),
 442                 -1,
 443                 cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get()
 444             ),
 445
 446             // Optional standard commands
 447
 448             ucb::CommandInfo(
 449                 OUString( "delete" ),
 450                 -1,
 451                 cppu::UnoType<bool>::get()
 452             ),
 453             ucb::CommandInfo(
 454                 OUString( "insert" ),
 455                 -1,
 456                 cppu::UnoType<void>::get()
 457             ),
 458             ucb::CommandInfo(
 459                 OUString( "open" ),
 460                 -1,
 461                 cppu::UnoType<ucb::OpenCommandArgument2>::get()
 462             )
 463
 464             // New commands
 465
 466         };
 467         return MAKECMDSEQUENCE( aStreamCommandInfoTable );
 468     }
 469     else if ( m_aProps.getType() == FOLDER )
 470     {
 471
 472
 473         // Folder: Supported commands
 474
 475
 476
 477         static const ucb::CommandInfo aFolderCommandInfoTable[] =
 478         {
 479
 480             // Mandatory commands
 481
 482             ucb::CommandInfo(
 483                 OUString( "getCommandInfo" ),
 484                 -1,
 485                 cppu::UnoType<void>::get()
 486             ),
 487             ucb::CommandInfo(
 488                 OUString( "getPropertySetInfo" ),
 489                 -1,
 490                 cppu::UnoType<void>::get()
 491             ),
 492             ucb::CommandInfo(
 493                 OUString( "getPropertyValues" ),
 494                 -1,
 495                 cppu::UnoType<uno::Sequence< beans::Property >>::get()
 496             ),
 497             ucb::CommandInfo(
 498                 OUString( "setPropertyValues" ),
 499                 -1,
 500                 cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get()
 501             ),
 502
 503             // Optional standard commands
 504
 505             ucb::CommandInfo(
 506                 OUString( "delete" ),
 507                 -1,
 508                 cppu::UnoType<bool>::get()
 509             ),
 510             ucb::CommandInfo(
 511                 OUString( "insert" ),
 512                 -1,
 513                 cppu::UnoType<void>::get()
 514             ),
 515             ucb::CommandInfo(
 516                 OUString( "open" ),
 517                 -1,
 518                 cppu::UnoType<ucb::OpenCommandArgument2>::get()
 519             ),
 520             ucb::CommandInfo(
 521                 OUString( "transfer" ),
 522                 -1,
 523                 cppu::UnoType<ucb::TransferInfo>::get()
 524             ),
 525             ucb::CommandInfo(
 526                 OUString( "createNewContent" ),
 527                 -1,
 528                 cppu::UnoType<ucb::ContentInfo>::get()
 529             )
 530
 531             // New commands
 532
 533         };
 534         return MAKECMDSEQUENCE( aFolderCommandInfoTable );
 535     }
 536     else if ( m_aProps.getType() == DOCUMENT )
 537     {
 538
 539
 540         // Document: Supported commands
 541
 542
 543
 544         static const ucb::CommandInfo aDocCommandInfoTable[] =
 545         {
 546
 547             // Mandatory commands
 548
 549             ucb::CommandInfo(
 550                 OUString( "getCommandInfo" ),
 551                 -1,
 552                 cppu::UnoType<void>::get()
 553             ),
 554             ucb::CommandInfo(
 555                 OUString( "getPropertySetInfo" ),
 556                 -1,
 557                 cppu::UnoType<void>::get()
 558             ),
 559             ucb::CommandInfo(
 560                 OUString( "getPropertyValues" ),
 561                 -1,
 562                 cppu::UnoType<uno::Sequence< beans::Property >>::get()
 563             ),
 564             ucb::CommandInfo(
 565                 OUString( "setPropertyValues" ),
 566                 -1,
 567                 cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get()
 568             ),
 569
 570             // Optional standard commands
 571
 572             ucb::CommandInfo(
 573                 OUString( "open" ),
 574                 -1,
 575                 cppu::UnoType<ucb::OpenCommandArgument2>::get()
 576             ),
 577             ucb::CommandInfo(
 578                 OUString( "transfer" ),
 579                 -1,
 580                 cppu::UnoType<ucb::TransferInfo>::get()
 581             ),
 582             ucb::CommandInfo(
 583                 OUString( "createNewContent" ),
 584                 -1,
 585                 cppu::UnoType<ucb::ContentInfo>::get()
 586             )
 587
 588             // New commands
 589
 590         };
 591         return MAKECMDSEQUENCE( aDocCommandInfoTable );
 592     }
 593     else
 594     {
 595
 596
 597         // Root: Supported commands
 598
 599
 600
 601         OSL_ENSURE( m_aProps.getType() == ROOT, "Wrong content type!" );
 602
 603         static const ucb::CommandInfo aRootCommandInfoTable[] =
 604         {
 605
 606             // Mandatory commands
 607
 608             ucb::CommandInfo(
 609                 OUString( "getCommandInfo" ),
 610                 -1,
 611                 cppu::UnoType<void>::get()
 612             ),
 613             ucb::CommandInfo(
 614                 OUString( "getPropertySetInfo" ),
 615                 -1,
 616                 cppu::UnoType<void>::get()
 617             ),
 618             ucb::CommandInfo(
 619                 OUString( "getPropertyValues" ),
 620                 -1,
 621                 cppu::UnoType<uno::Sequence< beans::Property >>::get()
 622             ),
 623             ucb::CommandInfo(
 624                 OUString( "setPropertyValues" ),
 625                 -1,
 626                 cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get()
 627             ),
 628
 629             // Optional standard commands
 630
 631             ucb::CommandInfo(
 632                 OUString( "open" ),
 633                 -1,
 634                 cppu::UnoType<ucb::OpenCommandArgument2>::get()
 635             )
 636
 637             // New commands
 638
 639         };
 640         return MAKECMDSEQUENCE( aRootCommandInfoTable );
 641     }
 642 }
 643
 644 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */