ucb/source/ucp/hierarchy/hierarchycontentcaps.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    folder  folder  link    link
  30                                    (new)           (new)
  31     ----------------------------------------------------------------
  32     ContentType            x       x       x       x       x
  33     IsDocument             x       x       x       x       x
  34     IsFolder               x       x       x       x       x
  35     Title                  x       x       x       x       x
  36     TargetURL                                      x       x
  37     CreatableContentsInfo  x       x       x       x       x
  38
  39     getCommandInfo         x       x       x       x       x
  40     getPropertySetInfo     x       x       x       x       x
  41     getPropertyValues      x       x       x       x       x
  42     setPropertyValues      x       x       x       x       x
  43     createNewContent       x               x
  44     insert                                 x               x
  45     delete                         x               x
  46     open                   x       x
  47     transfer               x       x
  48
  49  *************************************************************************/
  50
  51 #include <com/sun/star/beans/Property.hpp>
  52 #include <com/sun/star/beans/PropertyAttribute.hpp>
  53 #include <com/sun/star/beans/PropertyValue.hpp>
  54 #include <com/sun/star/ucb/CommandInfo.hpp>
  55 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
  56 #include <com/sun/star/ucb/TransferInfo.hpp>
  57 #include <com/sun/star/uno/Sequence.hxx>
  58 #include <sal/macros.h>
  59 #include "hierarchycontent.hxx"
  60
  61 using namespace com::sun::star;
  62 using namespace hierarchy_ucp;
  63
  64
  65
  66 // HierarchyContent implementation.
  67
  68
  69
  70 #define MAKEPROPSEQUENCE( a ) \
  71     uno::Sequence< beans::Property >( a, sizeof( a )  / sizeof( a[ 0 ] ) )
  72
  73 #define MAKECMDSEQUENCE( a ) \
  74     uno::Sequence< ucb::CommandInfo >( a, sizeof( a )  / sizeof( a[ 0 ] ) )
  75
  76
  77
  78 // IMPORTANT: If any property data ( name / type / ... ) are changed, then
  79 //            HierarchyContent::getPropertyValues(...) must be adapted too!
  80
  81
  82
  83 // virtual
  84 uno::Sequence< beans::Property > HierarchyContent::getProperties(
  85             const uno::Reference< ucb::XCommandEnvironment > & /*xEnv*/ )
  86 {
  87     osl::Guard< osl::Mutex > aGuard( m_aMutex );
  88
  89     if ( m_eKind == LINK )
  90     {
  91
  92
  93         // Link: Supported properties
  94
  95
  96
  97         if ( isReadOnly() )
  98         {
  99             static const beans::Property aLinkPropertyInfoTable[] =
 100             {
 101
 102                 // Required properties
 103
 104                 beans::Property(
 105                     OUString( "ContentType" ),
 106                     -1,
 107                     cppu::UnoType<OUString>::get(),
 108                     beans::PropertyAttribute::BOUND
 109                         | beans::PropertyAttribute::READONLY
 110                 ),
 111                 beans::Property(
 112                     OUString( "IsDocument" ),
 113                     -1,
 114                     cppu::UnoType<bool>::get(),
 115                     beans::PropertyAttribute::BOUND
 116                         | beans::PropertyAttribute::READONLY
 117                 ),
 118                 beans::Property(
 119                     OUString( "IsFolder" ),
 120                     -1,
 121                     cppu::UnoType<bool>::get(),
 122                     beans::PropertyAttribute::BOUND
 123                         | beans::PropertyAttribute::READONLY
 124                 ),
 125                 beans::Property(
 126                     OUString( "Title" ),
 127                     -1,
 128                     cppu::UnoType<OUString>::get(),
 129                     beans::PropertyAttribute::BOUND
 130                         | beans::PropertyAttribute::READONLY
 131                 ),
 132
 133                 // Optional standard properties
 134
 135                 beans::Property(
 136                     OUString( "TargetURL" ),
 137                     -1,
 138                     cppu::UnoType<OUString>::get(),
 139                     beans::PropertyAttribute::BOUND
 140                         | beans::PropertyAttribute::READONLY
 141                 ),
 142                 beans::Property(
 143                     OUString(
 144                         "CreatableContentsInfo" ),
 145                     -1,
 146                     cppu::UnoType<uno::Sequence< ucb::ContentInfo >>::get(),
 147                     beans::PropertyAttribute::BOUND
 148                         | beans::PropertyAttribute::READONLY )
 149
 150                 // New properties
 151
 152             };
 153             return MAKEPROPSEQUENCE( aLinkPropertyInfoTable );
 154         }
 155         else
 156         {
 157             static const beans::Property aLinkPropertyInfoTable[] =
 158             {
 159
 160                 // Required properties
 161
 162                 beans::Property(
 163                     OUString( "ContentType" ),
 164                     -1,
 165                     cppu::UnoType<OUString>::get(),
 166                     beans::PropertyAttribute::BOUND
 167                         | beans::PropertyAttribute::READONLY
 168                 ),
 169                 beans::Property(
 170                     OUString( "IsDocument" ),
 171                     -1,
 172                     cppu::UnoType<bool>::get(),
 173                     beans::PropertyAttribute::BOUND
 174                         | beans::PropertyAttribute::READONLY
 175                 ),
 176                 beans::Property(
 177                     OUString( "IsFolder" ),
 178                     -1,
 179                     cppu::UnoType<bool>::get(),
 180                     beans::PropertyAttribute::BOUND
 181                         | beans::PropertyAttribute::READONLY
 182                 ),
 183                 beans::Property(
 184                     OUString( "Title" ),
 185                     -1,
 186                     cppu::UnoType<OUString>::get(),
 187                     beans::PropertyAttribute::BOUND
 188                 ),
 189
 190                 // Optional standard properties
 191
 192                 beans::Property(
 193                     OUString( "TargetURL" ),
 194                     -1,
 195                     cppu::UnoType<OUString>::get(),
 196                     beans::PropertyAttribute::BOUND
 197                 ),
 198                 beans::Property(
 199                     OUString(
 200                         "CreatableContentsInfo" ),
 201                     -1,
 202                     cppu::UnoType<uno::Sequence< ucb::ContentInfo >>::get(),
 203                     beans::PropertyAttribute::BOUND
 204                         | beans::PropertyAttribute::READONLY )
 205
 206                 // New properties
 207
 208             };
 209             return MAKEPROPSEQUENCE( aLinkPropertyInfoTable );
 210         }
 211     }
 212     else if ( m_eKind == FOLDER )
 213     {
 214
 215
 216         // Folder: Supported properties
 217
 218
 219
 220         if ( isReadOnly() )
 221         {
 222             static const beans::Property aFolderPropertyInfoTable[] =
 223             {
 224
 225                 // Required properties
 226
 227                 beans::Property(
 228                     OUString( "ContentType" ),
 229                     -1,
 230                     cppu::UnoType<OUString>::get(),
 231                     beans::PropertyAttribute::BOUND
 232                         | beans::PropertyAttribute::READONLY
 233                 ),
 234                 beans::Property(
 235                     OUString( "IsDocument" ),
 236                     -1,
 237                     cppu::UnoType<bool>::get(),
 238                     beans::PropertyAttribute::BOUND
 239                         | beans::PropertyAttribute::READONLY
 240                 ),
 241                 beans::Property(
 242                     OUString( "IsFolder" ),
 243                     -1,
 244                     cppu::UnoType<bool>::get(),
 245                     beans::PropertyAttribute::BOUND
 246                         | beans::PropertyAttribute::READONLY
 247                 ),
 248                 beans::Property(
 249                     OUString( "Title" ),
 250                     -1,
 251                     cppu::UnoType<OUString>::get(),
 252                     beans::PropertyAttribute::BOUND
 253                         | beans::PropertyAttribute::READONLY
 254                 ),
 255
 256                 // Optional standard properties
 257
 258                 beans::Property(
 259                     OUString(
 260                         "CreatableContentsInfo" ),
 261                     -1,
 262                     cppu::UnoType<uno::Sequence< ucb::ContentInfo >>::get(),
 263                     beans::PropertyAttribute::BOUND
 264                         | beans::PropertyAttribute::READONLY )
 265
 266                 // New properties
 267
 268             };
 269             return MAKEPROPSEQUENCE( aFolderPropertyInfoTable );
 270         }
 271         else
 272         {
 273             static const beans::Property aFolderPropertyInfoTable[] =
 274             {
 275
 276                 // Required properties
 277
 278                 beans::Property(
 279                     OUString( "ContentType" ),
 280                     -1,
 281                     cppu::UnoType<OUString>::get(),
 282                     beans::PropertyAttribute::BOUND
 283                         | beans::PropertyAttribute::READONLY
 284                 ),
 285                 beans::Property(
 286                     OUString( "IsDocument" ),
 287                     -1,
 288                     cppu::UnoType<bool>::get(),
 289                     beans::PropertyAttribute::BOUND
 290                         | beans::PropertyAttribute::READONLY
 291                 ),
 292                 beans::Property(
 293                     OUString( "IsFolder" ),
 294                     -1,
 295                     cppu::UnoType<bool>::get(),
 296                     beans::PropertyAttribute::BOUND
 297                         | beans::PropertyAttribute::READONLY
 298                 ),
 299                 beans::Property(
 300                     OUString( "Title" ),
 301                     -1,
 302                     cppu::UnoType<OUString>::get(),
 303                     beans::PropertyAttribute::BOUND
 304                 ),
 305
 306                 // Optional standard properties
 307
 308                 beans::Property(
 309                     OUString(
 310                         "CreatableContentsInfo" ),
 311                     -1,
 312                     cppu::UnoType<uno::Sequence< ucb::ContentInfo >>::get(),
 313                     beans::PropertyAttribute::BOUND
 314                         | beans::PropertyAttribute::READONLY )
 315
 316                 // New properties
 317
 318             };
 319             return MAKEPROPSEQUENCE( aFolderPropertyInfoTable );
 320         }
 321     }
 322     else
 323     {
 324
 325
 326         // Root Folder: Supported properties
 327
 328
 329
 330         // Currently no difference between reonly /read-write
 331         // -> all props ar read-only
 332
 333         static const beans::Property aRootFolderPropertyInfoTable[] =
 334         {
 335
 336             // Required properties
 337
 338             beans::Property(
 339                 OUString( "ContentType" ),
 340                 -1,
 341                 cppu::UnoType<OUString>::get(),
 342                 beans::PropertyAttribute::BOUND
 343                     | beans::PropertyAttribute::READONLY
 344             ),
 345             beans::Property(
 346                 OUString( "IsDocument" ),
 347                 -1,
 348                 cppu::UnoType<bool>::get(),
 349                 beans::PropertyAttribute::BOUND
 350                     | beans::PropertyAttribute::READONLY
 351             ),
 352             beans::Property(
 353                 OUString( "IsFolder" ),
 354                 -1,
 355                 cppu::UnoType<bool>::get(),
 356                 beans::PropertyAttribute::BOUND
 357                     | beans::PropertyAttribute::READONLY
 358             ),
 359             beans::Property(
 360                 OUString( "Title" ),
 361                 -1,
 362                 cppu::UnoType<OUString>::get(),
 363                 beans::PropertyAttribute::BOUND
 364                     | beans::PropertyAttribute::READONLY
 365             ),
 366
 367             // Optional standard properties
 368
 369             beans::Property(
 370                     OUString(
 371                         "CreatableContentsInfo" ),
 372                     -1,
 373                     cppu::UnoType<uno::Sequence< ucb::ContentInfo >>::get(),
 374                     beans::PropertyAttribute::BOUND
 375                         | beans::PropertyAttribute::READONLY )
 376
 377             // New properties
 378
 379         };
 380         return MAKEPROPSEQUENCE( aRootFolderPropertyInfoTable );
 381     }
 382 }
 383
 384
 385 // virtual
 386 uno::Sequence< ucb::CommandInfo > HierarchyContent::getCommands(
 387             const uno::Reference< ucb::XCommandEnvironment > & /*xEnv*/ )
 388 {
 389     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 390
 391     if ( m_eKind == LINK )
 392     {
 393
 394
 395         // Link: Supported commands
 396
 397
 398
 399         if ( isReadOnly() )
 400         {
 401             static const ucb::CommandInfo aLinkCommandInfoTable[] =
 402             {
 403
 404                 // Required commands
 405
 406                 ucb::CommandInfo(
 407                     OUString( "getCommandInfo" ),
 408                     -1,
 409                     cppu::UnoType<void>::get()
 410                 ),
 411                 ucb::CommandInfo(
 412                     OUString( "getPropertySetInfo" ),
 413                     -1,
 414                     cppu::UnoType<void>::get()
 415                 ),
 416                 ucb::CommandInfo(
 417                     OUString( "getPropertyValues" ),
 418                     -1,
 419                     cppu::UnoType<uno::Sequence< beans::Property >>::get()
 420                 ),
 421                 ucb::CommandInfo(
 422                     OUString( "setPropertyValues" ),
 423                     -1,
 424                     cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get()
 425                 )
 426
 427                 // Optional standard commands
 428
 429
 430
 431                 // New commands
 432
 433             };
 434             return MAKECMDSEQUENCE( aLinkCommandInfoTable );
 435         }
 436         else
 437         {
 438             static const ucb::CommandInfo aLinkCommandInfoTable[] =
 439             {
 440
 441                 // Required commands
 442
 443                 ucb::CommandInfo(
 444                     OUString( "getCommandInfo" ),
 445                     -1,
 446                     cppu::UnoType<void>::get()
 447                 ),
 448                 ucb::CommandInfo(
 449                     OUString( "getPropertySetInfo" ),
 450                     -1,
 451                     cppu::UnoType<void>::get()
 452                 ),
 453                 ucb::CommandInfo(
 454                     OUString( "getPropertyValues" ),
 455                     -1,
 456                     cppu::UnoType<uno::Sequence< beans::Property >>::get()
 457                 ),
 458                 ucb::CommandInfo(
 459                     OUString( "setPropertyValues" ),
 460                     -1,
 461                     cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get()
 462                 ),
 463
 464                 // Optional standard commands
 465
 466                 ucb::CommandInfo(
 467                     OUString( "delete" ),
 468                     -1,
 469                     cppu::UnoType<bool>::get()
 470                 ),
 471                 ucb::CommandInfo(
 472                     OUString( "insert" ),
 473                     -1,
 474                     cppu::UnoType<void>::get()
 475                 )
 476
 477                 // New commands
 478
 479             };
 480             return MAKECMDSEQUENCE( aLinkCommandInfoTable );
 481         }
 482     }
 483     else if ( m_eKind == FOLDER )
 484     {
 485
 486
 487         // Folder: Supported commands
 488
 489
 490
 491         if ( isReadOnly() )
 492         {
 493             static const ucb::CommandInfo aFolderCommandInfoTable[] =
 494             {
 495
 496                 // Required commands
 497
 498                 ucb::CommandInfo(
 499                     OUString( "getCommandInfo" ),
 500                     -1,
 501                     cppu::UnoType<void>::get()
 502                 ),
 503                 ucb::CommandInfo(
 504                     OUString( "getPropertySetInfo" ),
 505                     -1,
 506                     cppu::UnoType<void>::get()
 507                 ),
 508                 ucb::CommandInfo(
 509                     OUString( "getPropertyValues" ),
 510                     -1,
 511                     cppu::UnoType<uno::Sequence< beans::Property >>::get()
 512                 ),
 513                 ucb::CommandInfo(
 514                     OUString( "setPropertyValues" ),
 515                     -1,
 516                     cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get()
 517                 ),
 518
 519                 // Optional standard commands
 520
 521                 ucb::CommandInfo(
 522                     OUString( "open" ),
 523                     -1,
 524                     cppu::UnoType<ucb::OpenCommandArgument2>::get()
 525                 )
 526
 527                 // New commands
 528
 529             };
 530             return MAKECMDSEQUENCE( aFolderCommandInfoTable );
 531         }
 532         else
 533         {
 534             static const ucb::CommandInfo aFolderCommandInfoTable[] =
 535             {
 536
 537                 // Required commands
 538
 539                 ucb::CommandInfo(
 540                     OUString( "getCommandInfo" ),
 541                     -1,
 542                     cppu::UnoType<void>::get()
 543                 ),
 544                 ucb::CommandInfo(
 545                     OUString( "getPropertySetInfo" ),
 546                     -1,
 547                     cppu::UnoType<void>::get()
 548                 ),
 549                 ucb::CommandInfo(
 550                     OUString( "getPropertyValues" ),
 551                     -1,
 552                     cppu::UnoType<uno::Sequence< beans::Property >>::get()
 553                 ),
 554                 ucb::CommandInfo(
 555                     OUString( "setPropertyValues" ),
 556                     -1,
 557                     cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get()
 558                 ),
 559
 560                 // Optional standard commands
 561
 562                 ucb::CommandInfo(
 563                     OUString( "delete" ),
 564                     -1,
 565                     cppu::UnoType<bool>::get()
 566                 ),
 567                 ucb::CommandInfo(
 568                     OUString( "insert" ),
 569                     -1,
 570                     cppu::UnoType<void>::get()
 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( aFolderCommandInfoTable );
 592         }
 593     }
 594     else
 595     {
 596
 597
 598         // Root Folder: Supported commands
 599
 600
 601
 602         if ( isReadOnly() )
 603         {
 604             static const ucb::CommandInfo aRootFolderCommandInfoTable[] =
 605             {
 606
 607                 // Required commands
 608
 609                 ucb::CommandInfo(
 610                     OUString( "getCommandInfo" ),
 611                     -1,
 612                     cppu::UnoType<void>::get()
 613                 ),
 614                 ucb::CommandInfo(
 615                     OUString( "getPropertySetInfo" ),
 616                     -1,
 617                     cppu::UnoType<void>::get()
 618                 ),
 619                 ucb::CommandInfo(
 620                     OUString( "getPropertyValues" ),
 621                     -1,
 622                     cppu::UnoType<uno::Sequence< beans::Property >>::get()
 623                 ),
 624                 ucb::CommandInfo(
 625                     OUString( "setPropertyValues" ),
 626                     -1,
 627                     cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get()
 628                 ),
 629
 630                 // Optional standard commands
 631
 632                 ucb::CommandInfo(
 633                     OUString( "open" ),
 634                     -1,
 635                     cppu::UnoType<ucb::OpenCommandArgument2>::get()
 636                 )
 637
 638                 // New commands
 639
 640             };
 641             return MAKECMDSEQUENCE( aRootFolderCommandInfoTable );
 642         }
 643         else
 644         {
 645             static const ucb::CommandInfo aRootFolderCommandInfoTable[] =
 646             {
 647
 648                 // Required commands
 649
 650                 ucb::CommandInfo(
 651                     OUString( "getCommandInfo" ),
 652                     -1,
 653                     cppu::UnoType<void>::get()
 654                 ),
 655                 ucb::CommandInfo(
 656                     OUString( "getPropertySetInfo" ),
 657                     -1,
 658                     cppu::UnoType<void>::get()
 659                 ),
 660                 ucb::CommandInfo(
 661                     OUString( "getPropertyValues" ),
 662                     -1,
 663                     cppu::UnoType<uno::Sequence< beans::Property >>::get()
 664                 ),
 665                 ucb::CommandInfo(
 666                     OUString( "setPropertyValues" ),
 667                     -1,
 668                     cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get()
 669                 ),
 670
 671                 // Optional standard commands
 672
 673                 ucb::CommandInfo(
 674                     OUString( "open" ),
 675                     -1,
 676                     cppu::UnoType<ucb::OpenCommandArgument2>::get()
 677                 ),
 678                 ucb::CommandInfo(
 679                     OUString( "transfer" ),
 680                     -1,
 681                     cppu::UnoType<ucb::TransferInfo>::get()
 682                 ),
 683                 ucb::CommandInfo(
 684                     OUString( "createNewContent" ),
 685                     -1,
 686                     cppu::UnoType<ucb::ContentInfo>::get()
 687                 )
 688
 689                 // New commands
 690
 691             };
 692             return MAKECMDSEQUENCE( aRootFolderCommandInfoTable );
 693         }
 694     }
 695 }
 696
 697 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */