001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.kernel.model; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.expando.kernel.model.ExpandoBridge; 020 021 import com.liferay.portal.kernel.service.ServiceContext; 022 023 import java.io.Serializable; 024 025 import java.util.HashMap; 026 import java.util.Map; 027 import java.util.Objects; 028 029 /** 030 * <p> 031 * This class is a wrapper for {@link Portlet}. 032 * </p> 033 * 034 * @author Brian Wing Shun Chan 035 * @see Portlet 036 * @generated 037 */ 038 @ProviderType 039 public class PortletWrapper implements Portlet, ModelWrapper<Portlet> { 040 public PortletWrapper(Portlet portlet) { 041 _portlet = portlet; 042 } 043 044 @Override 045 public Class<?> getModelClass() { 046 return Portlet.class; 047 } 048 049 @Override 050 public String getModelClassName() { 051 return Portlet.class.getName(); 052 } 053 054 @Override 055 public Map<String, Object> getModelAttributes() { 056 Map<String, Object> attributes = new HashMap<String, Object>(); 057 058 attributes.put("mvccVersion", getMvccVersion()); 059 attributes.put("id", getId()); 060 attributes.put("companyId", getCompanyId()); 061 attributes.put("portletId", getPortletId()); 062 attributes.put("roles", getRoles()); 063 attributes.put("active", getActive()); 064 065 return attributes; 066 } 067 068 @Override 069 public void setModelAttributes(Map<String, Object> attributes) { 070 Long mvccVersion = (Long)attributes.get("mvccVersion"); 071 072 if (mvccVersion != null) { 073 setMvccVersion(mvccVersion); 074 } 075 076 Long id = (Long)attributes.get("id"); 077 078 if (id != null) { 079 setId(id); 080 } 081 082 Long companyId = (Long)attributes.get("companyId"); 083 084 if (companyId != null) { 085 setCompanyId(companyId); 086 } 087 088 String portletId = (String)attributes.get("portletId"); 089 090 if (portletId != null) { 091 setPortletId(portletId); 092 } 093 094 String roles = (String)attributes.get("roles"); 095 096 if (roles != null) { 097 setRoles(roles); 098 } 099 100 Boolean active = (Boolean)attributes.get("active"); 101 102 if (active != null) { 103 setActive(active); 104 } 105 } 106 107 @Override 108 public CacheModel<Portlet> toCacheModel() { 109 return _portlet.toCacheModel(); 110 } 111 112 /** 113 * Get the default plugin settings of the portlet. 114 * 115 * @return the plugin settings 116 */ 117 @Override 118 public PluginSetting getDefaultPluginSetting() { 119 return _portlet.getDefaultPluginSetting(); 120 } 121 122 @Override 123 public Portlet toEscapedModel() { 124 return new PortletWrapper(_portlet.toEscapedModel()); 125 } 126 127 @Override 128 public Portlet toUnescapedModel() { 129 return new PortletWrapper(_portlet.toUnescapedModel()); 130 } 131 132 /** 133 * Returns this portlet's application. 134 * 135 * @return this portlet's application 136 */ 137 @Override 138 public PortletApp getPortletApp() { 139 return _portlet.getPortletApp(); 140 } 141 142 /** 143 * Returns the portlet info of the portlet. 144 * 145 * @return portlet info of the portlet 146 */ 147 @Override 148 public PortletInfo getPortletInfo() { 149 return _portlet.getPortletInfo(); 150 } 151 152 /** 153 * Returns the public render parameter from an identifier. 154 * 155 * @param identifier the identifier 156 * @return the public render parameter from an identifier 157 */ 158 @Override 159 public PublicRenderParameter getPublicRenderParameter( 160 java.lang.String identifier) { 161 return _portlet.getPublicRenderParameter(identifier); 162 } 163 164 /** 165 * Returns the spublic render parameter from a namespace URI and a local 166 * part. 167 * 168 * @param uri the namespace URI 169 * @param localPart the local part 170 * @return the spublic render parameter from a namespace URI and a local 171 part 172 */ 173 @Override 174 public PublicRenderParameter getPublicRenderParameter( 175 java.lang.String uri, java.lang.String localPart) { 176 return _portlet.getPublicRenderParameter(uri, localPart); 177 } 178 179 /** 180 * Returns <code>true</code> if an action URL for this portlet should cause 181 * an auto redirect. 182 * 183 * @return <code>true</code> if an action URL for this portlet should cause 184 an auto redirect 185 */ 186 @Override 187 public boolean getActionURLRedirect() { 188 return _portlet.getActionURLRedirect(); 189 } 190 191 /** 192 * Returns the active of this portlet. 193 * 194 * @return the active of this portlet 195 */ 196 @Override 197 public boolean getActive() { 198 return _portlet.getActive(); 199 } 200 201 /** 202 * Returns <code>true</code> if default resources for the portlet are added 203 * to a page. 204 * 205 * @return <code>true</code> if default resources for the portlet are added 206 to a page 207 */ 208 @Override 209 public boolean getAddDefaultResource() { 210 return _portlet.getAddDefaultResource(); 211 } 212 213 /** 214 * Returns <code>true</code> if the portlet can be displayed via Ajax. 215 * 216 * @return <code>true</code> if the portlet can be displayed via Ajax 217 */ 218 @Override 219 public boolean getAjaxable() { 220 return _portlet.getAjaxable(); 221 } 222 223 /** 224 * Returns <code>true</code> to include the portlet and make it available to 225 * be made active. 226 * 227 * @return <code>true</code> to include the portlet and make it available to 228 be made active 229 */ 230 @Override 231 public boolean getInclude() { 232 return _portlet.getInclude(); 233 } 234 235 /** 236 * Returns <code>true</code> if the portlet can be added multiple times to a 237 * layout. 238 * 239 * @return <code>true</code> if the portlet can be added multiple times to a 240 layout 241 */ 242 @Override 243 public boolean getInstanceable() { 244 return _portlet.getInstanceable(); 245 } 246 247 /** 248 * Returns <code>true</code> to allow the portlet to be cached within the 249 * layout. 250 * 251 * @return <code>true</code> if the portlet can be cached within the layout 252 */ 253 @Override 254 public boolean getLayoutCacheable() { 255 return _portlet.getLayoutCacheable(); 256 } 257 258 /** 259 * Returns <code>true</code> if the portlet goes into the maximized state 260 * when the user goes into the edit mode. 261 * 262 * @return <code>true</code> if the portlet goes into the maximized state 263 when the user goes into the edit mode 264 */ 265 @Override 266 public boolean getMaximizeEdit() { 267 return _portlet.getMaximizeEdit(); 268 } 269 270 /** 271 * Returns <code>true</code> if the portlet goes into the maximized state 272 * when the user goes into the help mode. 273 * 274 * @return <code>true</code> if the portlet goes into the maximized state 275 when the user goes into the help mode 276 */ 277 @Override 278 public boolean getMaximizeHelp() { 279 return _portlet.getMaximizeHelp(); 280 } 281 282 /** 283 * Returns <code>true</code> if the portlet goes into the pop up state when 284 * the user goes into the print mode. 285 * 286 * @return <code>true</code> if the portlet goes into the pop up state when 287 the user goes into the print mode 288 */ 289 @Override 290 public boolean getPopUpPrint() { 291 return _portlet.getPopUpPrint(); 292 } 293 294 /** 295 * Returns <code>true</code> if preferences are shared across the entire 296 * company. 297 * 298 * @return <code>true</code> if preferences are shared across the entire 299 company 300 */ 301 @Override 302 public boolean getPreferencesCompanyWide() { 303 return _portlet.getPreferencesCompanyWide(); 304 } 305 306 /** 307 * Returns <code>true</code> if preferences are owned by the group when the 308 * portlet is shown in a group layout. Returns <code>false</code> if 309 * preferences are owned by the user at all times. 310 * 311 * @return <code>true</code> if preferences are owned by the group when the 312 portlet is shown in a group layout; <code>false</code> if 313 preferences are owned by the user at all times. 314 */ 315 @Override 316 public boolean getPreferencesOwnedByGroup() { 317 return _portlet.getPreferencesOwnedByGroup(); 318 } 319 320 /** 321 * Returns <code>true</code> if preferences are unique per layout. 322 * 323 * @return <code>true</code> if preferences are unique per layout 324 */ 325 @Override 326 public boolean getPreferencesUniquePerLayout() { 327 return _portlet.getPreferencesUniquePerLayout(); 328 } 329 330 /** 331 * Returns <code>true</code> if the portlet does not share request 332 * attributes with the portal or portlets from another WAR. 333 * 334 * @return <code>true</code> if the portlet does not share request 335 attributes with the portal or portlets from another WAR 336 */ 337 @Override 338 public boolean getPrivateRequestAttributes() { 339 return _portlet.getPrivateRequestAttributes(); 340 } 341 342 /** 343 * Returns <code>true</code> if the portlet does not share session 344 * attributes with the portal. 345 * 346 * @return <code>true</code> if the portlet does not share session 347 attributes with the portal 348 */ 349 @Override 350 public boolean getPrivateSessionAttributes() { 351 return _portlet.getPrivateSessionAttributes(); 352 } 353 354 /** 355 * Returns <code>true</code> if the portlet is ready to be used. 356 * 357 * @return <code>true</code> if the portlet is ready to be used 358 */ 359 @Override 360 public boolean getReady() { 361 return _portlet.getReady(); 362 } 363 364 /** 365 * Returns <code>true</code> if the portlet supports remoting. 366 * 367 * @return <code>true</code> if the portlet supports remoting 368 */ 369 @Override 370 public boolean getRemoteable() { 371 return _portlet.getRemoteable(); 372 } 373 374 /** 375 * Returns <code>true</code> if the portlet restores to the current view 376 * from the maximized state. 377 * 378 * @return <code>true</code> if the portlet restores to the current view 379 from the maximized state 380 */ 381 @Override 382 public boolean getRestoreCurrentView() { 383 return _portlet.getRestoreCurrentView(); 384 } 385 386 /** 387 * Returns <code>true</code> if the portlet supports scoping of data. 388 * 389 * @return <code>true</code> if the portlet supports scoping of data 390 */ 391 @Override 392 public boolean getScopeable() { 393 return _portlet.getScopeable(); 394 } 395 396 /** 397 * Returns <code>true</code> if users are shown that they do not have access 398 * to the portlet. 399 * 400 * @return <code>true</code> if users are shown that they do not have access 401 to the portlet 402 */ 403 @Override 404 public boolean getShowPortletAccessDenied() { 405 return _portlet.getShowPortletAccessDenied(); 406 } 407 408 /** 409 * Returns <code>true</code> if users are shown that the portlet is 410 * inactive. 411 * 412 * @return <code>true</code> if users are shown that the portlet is inactive 413 */ 414 @Override 415 public boolean getShowPortletInactive() { 416 return _portlet.getShowPortletInactive(); 417 } 418 419 /** 420 * Returns <code>true</code> if the portlet uses Single Page Application. 421 * 422 * @return <code>true</code> if the portlet uses Single Page Application 423 */ 424 @Override 425 public boolean getSinglePageApplication() { 426 return _portlet.getSinglePageApplication(); 427 } 428 429 /** 430 * Returns <code>true</code> if the portlet is a static portlet that is 431 * cannot be moved. 432 * 433 * @return <code>true</code> if the portlet is a static portlet that is 434 cannot be moved 435 */ 436 @Override 437 public boolean getStatic() { 438 return _portlet.getStatic(); 439 } 440 441 /** 442 * Returns <code>true</code> if the portlet is a static portlet at the end 443 * of a list of portlets. 444 * 445 * @return <code>true</code> if the portlet is a static portlet at the end 446 of a list of portlets 447 */ 448 @Override 449 public boolean getStaticEnd() { 450 return _portlet.getStaticEnd(); 451 } 452 453 /** 454 * Returns <code>true</code> if the portlet is a static portlet at the start 455 * of a list of portlets. 456 * 457 * @return <code>true</code> if the portlet is a static portlet at the start 458 of a list of portlets 459 */ 460 @Override 461 public boolean getStaticStart() { 462 return _portlet.getStaticStart(); 463 } 464 465 /** 466 * Returns <code>true</code> if the portlet is a system portlet that a user 467 * cannot manually add to their page. 468 * 469 * @return <code>true</code> if the portlet is a system portlet that a user 470 cannot manually add to their page 471 */ 472 @Override 473 public boolean getSystem() { 474 return _portlet.getSystem(); 475 } 476 477 /** 478 * Returns <code>true</code> if the portlet is an undeployed portlet. 479 * 480 * @return <code>true</code> if the portlet is a placeholder of an 481 undeployed portlet 482 */ 483 @Override 484 public boolean getUndeployedPortlet() { 485 return _portlet.getUndeployedPortlet(); 486 } 487 488 /** 489 * Returns <code>true</code> if the portlet uses the default template. 490 * 491 * @return <code>true</code> if the portlet uses the default template 492 */ 493 @Override 494 public boolean getUseDefaultTemplate() { 495 return _portlet.getUseDefaultTemplate(); 496 } 497 498 /** 499 * Returns <code>true</code> if the user has the permission to add the 500 * portlet to a layout. 501 * 502 * @param userId the primary key of the user 503 * @return <code>true</code> if the user has the permission to add the 504 portlet to a layout 505 */ 506 @Override 507 public boolean hasAddPortletPermission(long userId) { 508 return _portlet.hasAddPortletPermission(userId); 509 } 510 511 @Override 512 public boolean hasFooterPortalCss() { 513 return _portlet.hasFooterPortalCss(); 514 } 515 516 @Override 517 public boolean hasFooterPortalJavaScript() { 518 return _portlet.hasFooterPortalJavaScript(); 519 } 520 521 @Override 522 public boolean hasFooterPortletCss() { 523 return _portlet.hasFooterPortletCss(); 524 } 525 526 @Override 527 public boolean hasFooterPortletJavaScript() { 528 return _portlet.hasFooterPortletJavaScript(); 529 } 530 531 @Override 532 public boolean hasHeaderPortalCss() { 533 return _portlet.hasHeaderPortalCss(); 534 } 535 536 @Override 537 public boolean hasHeaderPortalJavaScript() { 538 return _portlet.hasHeaderPortalJavaScript(); 539 } 540 541 @Override 542 public boolean hasHeaderPortletCss() { 543 return _portlet.hasHeaderPortletCss(); 544 } 545 546 @Override 547 public boolean hasHeaderPortletJavaScript() { 548 return _portlet.hasHeaderPortletJavaScript(); 549 } 550 551 /** 552 * Returns <code>true</code> if the portlet supports more than one mime 553 * type. 554 * 555 * @return <code>true</code> if the portlet supports more than one mime type 556 */ 557 @Override 558 public boolean hasMultipleMimeTypes() { 559 return _portlet.hasMultipleMimeTypes(); 560 } 561 562 /** 563 * Returns <code>true</code> if the portlet supports the specified mime type 564 * and portlet mode. 565 * 566 * @param mimeType the mime type 567 * @param portletMode the portlet mode 568 * @return <code>true</code> if the portlet supports the specified mime type 569 and portlet mode 570 */ 571 @Override 572 public boolean hasPortletMode(java.lang.String mimeType, 573 javax.portlet.PortletMode portletMode) { 574 return _portlet.hasPortletMode(mimeType, portletMode); 575 } 576 577 /** 578 * Returns <code>true</code> if the portlet has a role with the specified 579 * name. 580 * 581 * @param roleName the role name 582 * @return <code>true</code> if the portlet has a role with the specified 583 name 584 */ 585 @Override 586 public boolean hasRoleWithName(java.lang.String roleName) { 587 return _portlet.hasRoleWithName(roleName); 588 } 589 590 /** 591 * Returns <code>true</code> if the portlet supports the specified mime type 592 * and window state. 593 * 594 * @param mimeType the mime type 595 * @param windowState the window state 596 * @return <code>true</code> if the portlet supports the specified mime type 597 and window state 598 */ 599 @Override 600 public boolean hasWindowState(java.lang.String mimeType, 601 javax.portlet.WindowState windowState) { 602 return _portlet.hasWindowState(mimeType, windowState); 603 } 604 605 /** 606 * Returns <code>true</code> if an action URL for this portlet should cause 607 * an auto redirect. 608 * 609 * @return <code>true</code> if an action URL for this portlet should cause 610 an auto redirect 611 */ 612 @Override 613 public boolean isActionURLRedirect() { 614 return _portlet.isActionURLRedirect(); 615 } 616 617 /** 618 * Returns <code>true</code> if this portlet is active. 619 * 620 * @return <code>true</code> if this portlet is active; <code>false</code> otherwise 621 */ 622 @Override 623 public boolean isActive() { 624 return _portlet.isActive(); 625 } 626 627 /** 628 * Returns <code>true</code> if default resources for the portlet are added 629 * to a page. 630 * 631 * @return <code>true</code> if default resources for the portlet are added 632 to a page 633 */ 634 @Override 635 public boolean isAddDefaultResource() { 636 return _portlet.isAddDefaultResource(); 637 } 638 639 /** 640 * Returns <code>true</code> if the portlet can be displayed via Ajax. 641 * 642 * @return <code>true</code> if the portlet can be displayed via Ajax 643 */ 644 @Override 645 public boolean isAjaxable() { 646 return _portlet.isAjaxable(); 647 } 648 649 @Override 650 public boolean isCachedModel() { 651 return _portlet.isCachedModel(); 652 } 653 654 @Override 655 public boolean isEscapedModel() { 656 return _portlet.isEscapedModel(); 657 } 658 659 @Override 660 public boolean isFullPageDisplayable() { 661 return _portlet.isFullPageDisplayable(); 662 } 663 664 /** 665 * Returns <code>true</code> to include the portlet and make it available to 666 * be made active. 667 * 668 * @return <code>true</code> to include the portlet and make it available to 669 be made active 670 */ 671 @Override 672 public boolean isInclude() { 673 return _portlet.isInclude(); 674 } 675 676 /** 677 * Returns <code>true</code> if the portlet can be added multiple times to a 678 * layout. 679 * 680 * @return <code>true</code> if the portlet can be added multiple times to a 681 layout 682 */ 683 @Override 684 public boolean isInstanceable() { 685 return _portlet.isInstanceable(); 686 } 687 688 /** 689 * Returns <code>true</code> to allow the portlet to be cached within the 690 * layout. 691 * 692 * @return <code>true</code> if the portlet can be cached within the layout 693 */ 694 @Override 695 public boolean isLayoutCacheable() { 696 return _portlet.isLayoutCacheable(); 697 } 698 699 /** 700 * Returns <code>true</code> if the portlet goes into the maximized state 701 * when the user goes into the edit mode. 702 * 703 * @return <code>true</code> if the portlet goes into the maximized state 704 when the user goes into the edit mode 705 */ 706 @Override 707 public boolean isMaximizeEdit() { 708 return _portlet.isMaximizeEdit(); 709 } 710 711 /** 712 * Returns <code>true</code> if the portlet goes into the maximized state 713 * when the user goes into the help mode. 714 * 715 * @return <code>true</code> if the portlet goes into the maximized state 716 when the user goes into the help mode 717 */ 718 @Override 719 public boolean isMaximizeHelp() { 720 return _portlet.isMaximizeHelp(); 721 } 722 723 @Override 724 public boolean isNew() { 725 return _portlet.isNew(); 726 } 727 728 /** 729 * Returns <code>true</code> if the portlet goes into the pop up state when 730 * the user goes into the print mode. 731 * 732 * @return <code>true</code> if the portlet goes into the pop up state when 733 the user goes into the print mode 734 */ 735 @Override 736 public boolean isPopUpPrint() { 737 return _portlet.isPopUpPrint(); 738 } 739 740 /** 741 * Returns <code>true</code> if preferences are shared across the entire 742 * company. 743 * 744 * @return <code>true</code> if preferences are shared across the entire 745 company 746 */ 747 @Override 748 public boolean isPreferencesCompanyWide() { 749 return _portlet.isPreferencesCompanyWide(); 750 } 751 752 /** 753 * Returns <code>true</code> if preferences are owned by the group when the 754 * portlet is shown in a group layout. Returns <code>false</code> if 755 * preferences are owned by the user at all times. 756 * 757 * @return <code>true</code> if preferences are owned by the group when the 758 portlet is shown in a group layout; <code>false</code> if 759 preferences are owned by the user at all times. 760 */ 761 @Override 762 public boolean isPreferencesOwnedByGroup() { 763 return _portlet.isPreferencesOwnedByGroup(); 764 } 765 766 /** 767 * Returns <code>true</code> if preferences are unique per layout. 768 * 769 * @return <code>true</code> if preferences are unique per layout 770 */ 771 @Override 772 public boolean isPreferencesUniquePerLayout() { 773 return _portlet.isPreferencesUniquePerLayout(); 774 } 775 776 /** 777 * Returns <code>true</code> if the portlet does not share request 778 * attributes with the portal or portlets from another WAR. 779 * 780 * @return <code>true</code> if the portlet does not share request 781 attributes with the portal or portlets from another WAR 782 */ 783 @Override 784 public boolean isPrivateRequestAttributes() { 785 return _portlet.isPrivateRequestAttributes(); 786 } 787 788 /** 789 * Returns <code>true</code> if the portlet does not share session 790 * attributes with the portal. 791 * 792 * @return <code>true</code> if the portlet does not share session 793 attributes with the portal 794 */ 795 @Override 796 public boolean isPrivateSessionAttributes() { 797 return _portlet.isPrivateSessionAttributes(); 798 } 799 800 /** 801 * Returns <code>true</code> if the portlet is ready to be used. 802 * 803 * @return <code>true</code> if the portlet is ready to be used 804 */ 805 @Override 806 public boolean isReady() { 807 return _portlet.isReady(); 808 } 809 810 /** 811 * Returns <code>true</code> if the portlet supports remoting. 812 * 813 * @return <code>true</code> if the portlet supports remoting 814 */ 815 @Override 816 public boolean isRemoteable() { 817 return _portlet.isRemoteable(); 818 } 819 820 /** 821 * Returns <code>true</code> if the portlet will only process namespaced 822 * parameters. 823 * 824 * @return <code>true</code> if the portlet will only process namespaced 825 parameters 826 */ 827 @Override 828 public boolean isRequiresNamespacedParameters() { 829 return _portlet.isRequiresNamespacedParameters(); 830 } 831 832 /** 833 * Returns <code>true</code> if the portlet restores to the current view 834 * from the maximized state. 835 * 836 * @return <code>true</code> if the portlet restores to the current view 837 from the maximized state 838 */ 839 @Override 840 public boolean isRestoreCurrentView() { 841 return _portlet.isRestoreCurrentView(); 842 } 843 844 /** 845 * Returns <code>true</code> if the portlet supports scoping of data. 846 * 847 * @return <code>true</code> if the portlet supports scoping of data 848 */ 849 @Override 850 public boolean isScopeable() { 851 return _portlet.isScopeable(); 852 } 853 854 /** 855 * Returns <code>true</code> if users are shown that they do not have access 856 * to the portlet. 857 * 858 * @return <code>true</code> if users are shown that they do not have access 859 to the portlet 860 */ 861 @Override 862 public boolean isShowPortletAccessDenied() { 863 return _portlet.isShowPortletAccessDenied(); 864 } 865 866 /** 867 * Returns <code>true</code> if users are shown that the portlet is 868 * inactive. 869 * 870 * @return <code>true</code> if users are shown that the portlet is inactive 871 */ 872 @Override 873 public boolean isShowPortletInactive() { 874 return _portlet.isShowPortletInactive(); 875 } 876 877 /** 878 * Returns <code>true</code> if the portlet uses Single Page Application. 879 * 880 * @return <code>true</code> if the portlet uses Single Page Application 881 */ 882 @Override 883 public boolean isSinglePageApplication() { 884 return _portlet.isSinglePageApplication(); 885 } 886 887 /** 888 * Returns <code>true</code> if the portlet is a static portlet that is 889 * cannot be moved. 890 * 891 * @return <code>true</code> if the portlet is a static portlet that is 892 cannot be moved 893 */ 894 @Override 895 public boolean isStatic() { 896 return _portlet.isStatic(); 897 } 898 899 /** 900 * Returns <code>true</code> if the portlet is a static portlet at the end 901 * of a list of portlets. 902 * 903 * @return <code>true</code> if the portlet is a static portlet at the end 904 of a list of portlets 905 */ 906 @Override 907 public boolean isStaticEnd() { 908 return _portlet.isStaticEnd(); 909 } 910 911 /** 912 * Returns <code>true</code> if the portlet is a static portlet at the start 913 * of a list of portlets. 914 * 915 * @return <code>true</code> if the portlet is a static portlet at the start 916 of a list of portlets 917 */ 918 @Override 919 public boolean isStaticStart() { 920 return _portlet.isStaticStart(); 921 } 922 923 /** 924 * Returns <code>true</code> if the portlet is a system portlet that a user 925 * cannot manually add to their page. 926 * 927 * @return <code>true</code> if the portlet is a system portlet that a user 928 cannot manually add to their page 929 */ 930 @Override 931 public boolean isSystem() { 932 return _portlet.isSystem(); 933 } 934 935 /** 936 * Returns <code>true</code> if the portlet is an undeployed portlet. 937 * 938 * @return <code>true</code> if the portlet is a placeholder of an 939 undeployed portlet 940 */ 941 @Override 942 public boolean isUndeployedPortlet() { 943 return _portlet.isUndeployedPortlet(); 944 } 945 946 /** 947 * Returns <code>true</code> if the portlet uses the default template. 948 * 949 * @return <code>true</code> if the portlet uses the default template 950 */ 951 @Override 952 public boolean isUseDefaultTemplate() { 953 return _portlet.isUseDefaultTemplate(); 954 } 955 956 @Override 957 public ExpandoBridge getExpandoBridge() { 958 return _portlet.getExpandoBridge(); 959 } 960 961 /** 962 * Returns the portlet data handler instance of the portlet. 963 * 964 * @return the portlet data handler instance of the portlet 965 */ 966 @Override 967 public com.liferay.exportimport.kernel.lar.PortletDataHandler getPortletDataHandlerInstance() { 968 return _portlet.getPortletDataHandlerInstance(); 969 } 970 971 /** 972 * Returns <code>true</code> if the portlet is found in a WAR file. 973 * 974 * @param portletId the cloned instance portlet ID 975 * @return a cloned instance of the portlet 976 */ 977 @Override 978 public Portlet getClonedInstance(java.lang.String portletId) { 979 return _portlet.getClonedInstance(portletId); 980 } 981 982 /** 983 * Returns the root portlet of this portlet instance. 984 * 985 * @return the root portlet of this portlet instance 986 */ 987 @Override 988 public Portlet getRootPortlet() { 989 return _portlet.getRootPortlet(); 990 } 991 992 /** 993 * Returns this portlet's plugin package. 994 * 995 * @return this portlet's plugin package 996 */ 997 @Override 998 public com.liferay.portal.kernel.plugin.PluginPackage getPluginPackage() { 999 return _portlet.getPluginPackage(); 1000 } 1001 1002 /** 1003 * Returns the poller processor instance of the portlet. 1004 * 1005 * @return the poller processor instance of the portlet 1006 */ 1007 @Override 1008 public com.liferay.portal.kernel.poller.PollerProcessor getPollerProcessorInstance() { 1009 return _portlet.getPollerProcessorInstance(); 1010 } 1011 1012 /** 1013 * Returns the POP message listener instance of the portlet. 1014 * 1015 * @return the POP message listener instance of the portlet 1016 */ 1017 @Override 1018 public com.liferay.portal.kernel.pop.MessageListener getPopMessageListenerInstance() { 1019 return _portlet.getPopMessageListenerInstance(); 1020 } 1021 1022 /** 1023 * Returns the configuration action instance of the portlet. 1024 * 1025 * @return the configuration action instance of the portlet 1026 */ 1027 @Override 1028 public com.liferay.portal.kernel.portlet.ConfigurationAction getConfigurationActionInstance() { 1029 return _portlet.getConfigurationActionInstance(); 1030 } 1031 1032 /** 1033 * Returns an instance of the class that will control when the portlet will 1034 * be shown in the Control Panel. 1035 * 1036 * @return the instance of the class that will control when the portlet will 1037 be shown in the Control Panel 1038 */ 1039 @Override 1040 public com.liferay.portal.kernel.portlet.ControlPanelEntry getControlPanelEntryInstance() { 1041 return _portlet.getControlPanelEntryInstance(); 1042 } 1043 1044 /** 1045 * Returns the friendly URL mapper instance of the portlet. 1046 * 1047 * @return the friendly URL mapper instance of the portlet 1048 */ 1049 @Override 1050 public com.liferay.portal.kernel.portlet.FriendlyURLMapper getFriendlyURLMapperInstance() { 1051 return _portlet.getFriendlyURLMapperInstance(); 1052 } 1053 1054 /** 1055 * Returns the portlet layout listener instance of the portlet. 1056 * 1057 * @return the portlet layout listener instance of the portlet 1058 */ 1059 @Override 1060 public com.liferay.portal.kernel.portlet.PortletLayoutListener getPortletLayoutListenerInstance() { 1061 return _portlet.getPortletLayoutListenerInstance(); 1062 } 1063 1064 /** 1065 * Returns the indexer instance of the portlet. 1066 * 1067 * @return the indexer instance of the portlet 1068 */ 1069 @Override 1070 public com.liferay.portal.kernel.search.OpenSearch getOpenSearchInstance() { 1071 return _portlet.getOpenSearchInstance(); 1072 } 1073 1074 /** 1075 * Returns the permission propagator instance of the portlet. 1076 * 1077 * @return the permission propagator instance of the portlet 1078 */ 1079 @Override 1080 public com.liferay.portal.kernel.security.permission.PermissionPropagator getPermissionPropagatorInstance() { 1081 return _portlet.getPermissionPropagatorInstance(); 1082 } 1083 1084 /** 1085 * Returns the URL encoder instance of the portlet. 1086 * 1087 * @return the URL encoder instance of the portlet 1088 */ 1089 @Override 1090 public com.liferay.portal.kernel.servlet.URLEncoder getURLEncoderInstance() { 1091 return _portlet.getURLEncoderInstance(); 1092 } 1093 1094 /** 1095 * Returns the template handler instance of the portlet. 1096 * 1097 * @return the template handler instance of the portlet 1098 */ 1099 @Override 1100 public com.liferay.portal.kernel.template.TemplateHandler getTemplateHandlerInstance() { 1101 return _portlet.getTemplateHandlerInstance(); 1102 } 1103 1104 /** 1105 * Returns the name of the WebDAV storage instance of the portlet. 1106 * 1107 * @return the name of the WebDAV storage instance of the portlet 1108 */ 1109 @Override 1110 public com.liferay.portal.kernel.webdav.WebDAVStorage getWebDAVStorageInstance() { 1111 return _portlet.getWebDAVStorageInstance(); 1112 } 1113 1114 /** 1115 * Returns the processing event from a namespace URI and a local part. 1116 * 1117 * @param uri the namespace URI 1118 * @param localPart the local part 1119 * @return the processing event from a namespace URI and a local part 1120 */ 1121 @Override 1122 public com.liferay.portal.kernel.xml.QName getProcessingEvent( 1123 java.lang.String uri, java.lang.String localPart) { 1124 return _portlet.getProcessingEvent(uri, localPart); 1125 } 1126 1127 /** 1128 * Returns the name of the XML-RPC method instance of the portlet. 1129 * 1130 * @return the name of the XML-RPC method instance of the portlet 1131 */ 1132 @Override 1133 public com.liferay.portal.kernel.xmlrpc.Method getXmlRpcMethodInstance() { 1134 return _portlet.getXmlRpcMethodInstance(); 1135 } 1136 1137 /** 1138 * Returns the name of the social request interpreter instance of the 1139 * portlet. 1140 * 1141 * @return the name of the social request interpreter instance of the 1142 portlet 1143 */ 1144 @Override 1145 public com.liferay.social.kernel.model.SocialRequestInterpreter getSocialRequestInterpreterInstance() { 1146 return _portlet.getSocialRequestInterpreterInstance(); 1147 } 1148 1149 /** 1150 * Returns the relative weight of the portlet with respect to the other 1151 * portlets in the same category of the Control Panel. 1152 * 1153 * @return the relative weight of the portlet with respect to the other 1154 portlets in the same category of the Control Panel 1155 */ 1156 @Override 1157 public double getControlPanelEntryWeight() { 1158 return _portlet.getControlPanelEntryWeight(); 1159 } 1160 1161 @Override 1162 public int compareTo(Portlet portlet) { 1163 return _portlet.compareTo(portlet); 1164 } 1165 1166 /** 1167 * Returns the action timeout of the portlet. 1168 * 1169 * @return the action timeout of the portlet 1170 */ 1171 @Override 1172 public int getActionTimeout() { 1173 return _portlet.getActionTimeout(); 1174 } 1175 1176 /** 1177 * Returns the render timeout of the portlet. 1178 * 1179 * @return the render timeout of the portlet 1180 */ 1181 @Override 1182 public int getRenderTimeout() { 1183 return _portlet.getRenderTimeout(); 1184 } 1185 1186 /** 1187 * Returns the render weight of the portlet. 1188 * 1189 * @return the render weight of the portlet 1190 */ 1191 @Override 1192 public int getRenderWeight() { 1193 return _portlet.getRenderWeight(); 1194 } 1195 1196 @Override 1197 public int hashCode() { 1198 return _portlet.hashCode(); 1199 } 1200 1201 @Override 1202 public Serializable getPrimaryKeyObj() { 1203 return _portlet.getPrimaryKeyObj(); 1204 } 1205 1206 /** 1207 * Returns expiration cache of the portlet. 1208 * 1209 * @return expiration cache of the portlet 1210 */ 1211 @Override 1212 public java.lang.Integer getExpCache() { 1213 return _portlet.getExpCache(); 1214 } 1215 1216 @Override 1217 public java.lang.Object clone() { 1218 return new PortletWrapper((Portlet)_portlet.clone()); 1219 } 1220 1221 /** 1222 * Returns the configuration action class of the portlet. 1223 * 1224 * @return the configuration action class of the portlet 1225 */ 1226 @Override 1227 public java.lang.String getConfigurationActionClass() { 1228 return _portlet.getConfigurationActionClass(); 1229 } 1230 1231 /** 1232 * Returns the servlet context name of the portlet. 1233 * 1234 * @return the servlet context name of the portlet 1235 */ 1236 @Override 1237 public java.lang.String getContextName() { 1238 return _portlet.getContextName(); 1239 } 1240 1241 /** 1242 * Returns the servlet context path of the portlet. 1243 * 1244 * @return the servlet context path of the portlet 1245 */ 1246 @Override 1247 public java.lang.String getContextPath() { 1248 return _portlet.getContextPath(); 1249 } 1250 1251 /** 1252 * Returns the name of the category of the Control Panel where the portlet 1253 * will be shown. 1254 * 1255 * @return the name of the category of the Control Panel where the portlet 1256 will be shown 1257 */ 1258 @Override 1259 public java.lang.String getControlPanelEntryCategory() { 1260 return _portlet.getControlPanelEntryCategory(); 1261 } 1262 1263 /** 1264 * Returns the name of the class that will control when the portlet will be 1265 * shown in the Control Panel. 1266 * 1267 * @return the name of the class that will control when the portlet will be 1268 shown in the Control Panel 1269 */ 1270 @Override 1271 public java.lang.String getControlPanelEntryClass() { 1272 return _portlet.getControlPanelEntryClass(); 1273 } 1274 1275 /** 1276 * Returns the name of the CSS class that will be injected in the DIV that 1277 * wraps this portlet. 1278 * 1279 * @return the name of the CSS class that will be injected in the DIV that 1280 wraps this portlet 1281 */ 1282 @Override 1283 public java.lang.String getCssClassWrapper() { 1284 return _portlet.getCssClassWrapper(); 1285 } 1286 1287 /** 1288 * Returns the default preferences of the portlet. 1289 * 1290 * @return the default preferences of the portlet 1291 */ 1292 @Override 1293 public java.lang.String getDefaultPreferences() { 1294 return _portlet.getDefaultPreferences(); 1295 } 1296 1297 /** 1298 * Returns the display name of the portlet. 1299 * 1300 * @return the display name of the portlet 1301 */ 1302 @Override 1303 public java.lang.String getDisplayName() { 1304 return _portlet.getDisplayName(); 1305 } 1306 1307 /** 1308 * Returns the Facebook integration method of the portlet. 1309 * 1310 * @return the Facebook integration method of the portlet 1311 */ 1312 @Override 1313 public java.lang.String getFacebookIntegration() { 1314 return _portlet.getFacebookIntegration(); 1315 } 1316 1317 /** 1318 * Returns the name of the friendly URL mapper class of the portlet. 1319 * 1320 * @return the name of the friendly URL mapper class of the portlet 1321 */ 1322 @Override 1323 public java.lang.String getFriendlyURLMapperClass() { 1324 return _portlet.getFriendlyURLMapperClass(); 1325 } 1326 1327 /** 1328 * Returns the name of the friendly URL mapping of the portlet. 1329 * 1330 * @return the name of the friendly URL mapping of the portlet 1331 */ 1332 @Override 1333 public java.lang.String getFriendlyURLMapping() { 1334 return _portlet.getFriendlyURLMapping(); 1335 } 1336 1337 /** 1338 * Returns the class loader resource path to the friendly URL routes of the 1339 * portlet. 1340 * 1341 * @return the class loader resource path to the friendly URL routes of the 1342 portlet 1343 */ 1344 @Override 1345 public java.lang.String getFriendlyURLRoutes() { 1346 return _portlet.getFriendlyURLRoutes(); 1347 } 1348 1349 /** 1350 * Returns the icon of the portlet. 1351 * 1352 * @return the icon of the portlet 1353 */ 1354 @Override 1355 public java.lang.String getIcon() { 1356 return _portlet.getIcon(); 1357 } 1358 1359 /** 1360 * Returns the instance ID of the portlet. 1361 * 1362 * @return the instance ID of the portlet 1363 */ 1364 @Override 1365 public java.lang.String getInstanceId() { 1366 return _portlet.getInstanceId(); 1367 } 1368 1369 /** 1370 * Returns the name of the open search class of the portlet. 1371 * 1372 * @return the name of the open search class of the portlet 1373 */ 1374 @Override 1375 public java.lang.String getOpenSearchClass() { 1376 return _portlet.getOpenSearchClass(); 1377 } 1378 1379 /** 1380 * Returns the parent struts path of the portlet. 1381 * 1382 * @return the parent struts path of the portlet. 1383 */ 1384 @Override 1385 public java.lang.String getParentStrutsPath() { 1386 return _portlet.getParentStrutsPath(); 1387 } 1388 1389 /** 1390 * Returns the name of the permission propagator class of the portlet. 1391 * 1392 * @return the name of the permission propagator class of the portlet 1393 */ 1394 @Override 1395 public java.lang.String getPermissionPropagatorClass() { 1396 return _portlet.getPermissionPropagatorClass(); 1397 } 1398 1399 /** 1400 * Returns the plugin ID of the portlet. 1401 * 1402 * @return the plugin ID of the portlet 1403 */ 1404 @Override 1405 public java.lang.String getPluginId() { 1406 return _portlet.getPluginId(); 1407 } 1408 1409 /** 1410 * Returns the plugin type of the portlet. 1411 * 1412 * @return the plugin type of the portlet 1413 */ 1414 @Override 1415 public java.lang.String getPluginType() { 1416 return _portlet.getPluginType(); 1417 } 1418 1419 /** 1420 * Returns the name of the poller processor class of the portlet. 1421 * 1422 * @return the name of the poller processor class of the portlet 1423 */ 1424 @Override 1425 public java.lang.String getPollerProcessorClass() { 1426 return _portlet.getPollerProcessorClass(); 1427 } 1428 1429 /** 1430 * Returns the name of the POP message listener class of the portlet. 1431 * 1432 * @return the name of the POP message listener class of the portlet 1433 */ 1434 @Override 1435 public java.lang.String getPopMessageListenerClass() { 1436 return _portlet.getPopMessageListenerClass(); 1437 } 1438 1439 /** 1440 * Returns the name of the portlet class of the portlet. 1441 * 1442 * @return the name of the portlet class of the portlet 1443 */ 1444 @Override 1445 public java.lang.String getPortletClass() { 1446 return _portlet.getPortletClass(); 1447 } 1448 1449 /** 1450 * Returns the name of the portlet data handler class of the portlet. 1451 * 1452 * @return the name of the portlet data handler class of the portlet 1453 */ 1454 @Override 1455 public java.lang.String getPortletDataHandlerClass() { 1456 return _portlet.getPortletDataHandlerClass(); 1457 } 1458 1459 /** 1460 * Returns the portlet ID of this portlet. 1461 * 1462 * @return the portlet ID of this portlet 1463 */ 1464 @Override 1465 public java.lang.String getPortletId() { 1466 return _portlet.getPortletId(); 1467 } 1468 1469 /** 1470 * Returns the name of the portlet layout listener class of the portlet. 1471 * 1472 * @return the name of the portlet layout listener class of the portlet 1473 */ 1474 @Override 1475 public java.lang.String getPortletLayoutListenerClass() { 1476 return _portlet.getPortletLayoutListenerClass(); 1477 } 1478 1479 /** 1480 * Returns the name of the portlet. 1481 * 1482 * @return the display name of the portlet 1483 */ 1484 @Override 1485 public java.lang.String getPortletName() { 1486 return _portlet.getPortletName(); 1487 } 1488 1489 /** 1490 * Returns the name of the portlet URL class of the portlet. 1491 * 1492 * @return the name of the portlet URL class of the portlet 1493 */ 1494 @Override 1495 public java.lang.String getPortletURLClass() { 1496 return _portlet.getPortletURLClass(); 1497 } 1498 1499 /** 1500 * Returns the name of the preferences validator class of the portlet. 1501 * 1502 * @return the name of the preferences validator class of the portlet 1503 */ 1504 @Override 1505 public java.lang.String getPreferencesValidator() { 1506 return _portlet.getPreferencesValidator(); 1507 } 1508 1509 /** 1510 * Returns the resource bundle of the portlet. 1511 * 1512 * @return resource bundle of the portlet 1513 */ 1514 @Override 1515 public java.lang.String getResourceBundle() { 1516 return _portlet.getResourceBundle(); 1517 } 1518 1519 /** 1520 * Returns the roles of this portlet. 1521 * 1522 * @return the roles of this portlet 1523 */ 1524 @Override 1525 public java.lang.String getRoles() { 1526 return _portlet.getRoles(); 1527 } 1528 1529 /** 1530 * Returns the root portlet ID of the portlet. 1531 * 1532 * @return the root portlet ID of the portlet 1533 */ 1534 @Override 1535 public java.lang.String getRootPortletId() { 1536 return _portlet.getRootPortletId(); 1537 } 1538 1539 /** 1540 * Returns the name of the social request interpreter class of the portlet. 1541 * 1542 * @return the name of the social request interpreter class of the portlet 1543 */ 1544 @Override 1545 public java.lang.String getSocialRequestInterpreterClass() { 1546 return _portlet.getSocialRequestInterpreterClass(); 1547 } 1548 1549 /** 1550 * Returns the path for static resources served by this portlet. 1551 * 1552 * @return the path for static resources served by this portlet 1553 */ 1554 @Override 1555 public java.lang.String getStaticResourcePath() { 1556 return _portlet.getStaticResourcePath(); 1557 } 1558 1559 /** 1560 * Returns the struts path of the portlet. 1561 * 1562 * @return the struts path of the portlet 1563 */ 1564 @Override 1565 public java.lang.String getStrutsPath() { 1566 return _portlet.getStrutsPath(); 1567 } 1568 1569 /** 1570 * Returns the name of the template handler class of the portlet. 1571 * 1572 * @return the name of the template handler class of the portlet 1573 */ 1574 @Override 1575 public java.lang.String getTemplateHandlerClass() { 1576 return _portlet.getTemplateHandlerClass(); 1577 } 1578 1579 /** 1580 * Returns the name of the URL encoder class of the portlet. 1581 * 1582 * @return the name of the URL encoder class of the portlet 1583 */ 1584 @Override 1585 public java.lang.String getURLEncoderClass() { 1586 return _portlet.getURLEncoderClass(); 1587 } 1588 1589 /** 1590 * Returns the class loader resource path to the use notification 1591 * definitions of the portlet. 1592 * 1593 * @return the class loader resource path to the use notification 1594 definitions of the portlet 1595 */ 1596 @Override 1597 public java.lang.String getUserNotificationDefinitions() { 1598 return _portlet.getUserNotificationDefinitions(); 1599 } 1600 1601 /** 1602 * Returns the user principal strategy of the portlet. 1603 * 1604 * @return the user principal strategy of the portlet 1605 */ 1606 @Override 1607 public java.lang.String getUserPrincipalStrategy() { 1608 return _portlet.getUserPrincipalStrategy(); 1609 } 1610 1611 /** 1612 * Returns the virtual path of the portlet. 1613 * 1614 * @return the virtual path of the portlet 1615 */ 1616 @Override 1617 public java.lang.String getVirtualPath() { 1618 return _portlet.getVirtualPath(); 1619 } 1620 1621 /** 1622 * Returns the name of the WebDAV storage class of the portlet. 1623 * 1624 * @return the name of the WebDAV storage class of the portlet 1625 */ 1626 @Override 1627 public java.lang.String getWebDAVStorageClass() { 1628 return _portlet.getWebDAVStorageClass(); 1629 } 1630 1631 /** 1632 * Returns the name of the WebDAV storage token of the portlet. 1633 * 1634 * @return the name of the WebDAV storage token of the portlet 1635 */ 1636 @Override 1637 public java.lang.String getWebDAVStorageToken() { 1638 return _portlet.getWebDAVStorageToken(); 1639 } 1640 1641 /** 1642 * Returns the name of the XML-RPC method class of the portlet. 1643 * 1644 * @return the name of the XML-RPC method class of the portlet 1645 */ 1646 @Override 1647 public java.lang.String getXmlRpcMethodClass() { 1648 return _portlet.getXmlRpcMethodClass(); 1649 } 1650 1651 @Override 1652 public java.lang.String toString() { 1653 return _portlet.toString(); 1654 } 1655 1656 @Override 1657 public java.lang.String toXmlString() { 1658 return _portlet.toXmlString(); 1659 } 1660 1661 /** 1662 * Returns an array of required roles of the portlet. 1663 * 1664 * @return an array of required roles of the portlet 1665 */ 1666 @Override 1667 public java.lang.String[] getRolesArray() { 1668 return _portlet.getRolesArray(); 1669 } 1670 1671 /** 1672 * Returns the names of the classes that represent asset types associated 1673 * with the portlet. 1674 * 1675 * @return the names of the classes that represent asset types associated 1676 with the portlet 1677 */ 1678 @Override 1679 public java.util.List<java.lang.String> getAssetRendererFactoryClasses() { 1680 return _portlet.getAssetRendererFactoryClasses(); 1681 } 1682 1683 /** 1684 * Returns the asset type instances of the portlet. 1685 * 1686 * @return the asset type instances of the portlet 1687 */ 1688 @Override 1689 public java.util.List<com.liferay.asset.kernel.model.AssetRendererFactory<?>> getAssetRendererFactoryInstances() { 1690 return _portlet.getAssetRendererFactoryInstances(); 1691 } 1692 1693 /** 1694 * Returns the names of the classes that represent atom collection adapters 1695 * associated with the portlet. 1696 * 1697 * @return the names of the classes that represent atom collection adapters 1698 associated with the portlet 1699 */ 1700 @Override 1701 public java.util.List<java.lang.String> getAtomCollectionAdapterClasses() { 1702 return _portlet.getAtomCollectionAdapterClasses(); 1703 } 1704 1705 /** 1706 * Returns the atom collection adapter instances of the portlet. 1707 * 1708 * @return the atom collection adapter instances of the portlet 1709 */ 1710 @Override 1711 public java.util.List<com.liferay.portal.kernel.atom.AtomCollectionAdapter<?>> getAtomCollectionAdapterInstances() { 1712 return _portlet.getAtomCollectionAdapterInstances(); 1713 } 1714 1715 /** 1716 * Returns the names of the classes that represent custom attribute displays 1717 * associated with the portlet. 1718 * 1719 * @return the names of the classes that represent asset types associated 1720 with the portlet 1721 */ 1722 @Override 1723 public java.util.List<java.lang.String> getCustomAttributesDisplayClasses() { 1724 return _portlet.getCustomAttributesDisplayClasses(); 1725 } 1726 1727 /** 1728 * Returns the custom attribute display instances of the portlet. 1729 * 1730 * @return the custom attribute display instances of the portlet 1731 */ 1732 @Override 1733 public java.util.List<com.liferay.expando.kernel.model.CustomAttributesDisplay> getCustomAttributesDisplayInstances() { 1734 return _portlet.getCustomAttributesDisplayInstances(); 1735 } 1736 1737 /** 1738 * Returns a list of CSS files that will be referenced from the page's 1739 * footer relative to the portal's context path. 1740 * 1741 * @return a list of CSS files that will be referenced from the page's 1742 footer relative to the portal's context path 1743 */ 1744 @Override 1745 public java.util.List<java.lang.String> getFooterPortalCss() { 1746 return _portlet.getFooterPortalCss(); 1747 } 1748 1749 /** 1750 * Returns a list of JavaScript files that will be referenced from the 1751 * page's footer relative to the portal's context path. 1752 * 1753 * @return a list of JavaScript files that will be referenced from the 1754 page's footer relative to the portal's context path 1755 */ 1756 @Override 1757 public java.util.List<java.lang.String> getFooterPortalJavaScript() { 1758 return _portlet.getFooterPortalJavaScript(); 1759 } 1760 1761 /** 1762 * Returns a list of CSS files that will be referenced from the page's 1763 * footer relative to the portlet's context path. 1764 * 1765 * @return a list of CSS files that will be referenced from the page's 1766 footer relative to the portlet's context path 1767 */ 1768 @Override 1769 public java.util.List<java.lang.String> getFooterPortletCss() { 1770 return _portlet.getFooterPortletCss(); 1771 } 1772 1773 /** 1774 * Returns a list of JavaScript files that will be referenced from the 1775 * page's footer relative to the portlet's context path. 1776 * 1777 * @return a list of JavaScript files that will be referenced from the 1778 page's footer relative to the portlet's context path 1779 */ 1780 @Override 1781 public java.util.List<java.lang.String> getFooterPortletJavaScript() { 1782 return _portlet.getFooterPortletJavaScript(); 1783 } 1784 1785 /** 1786 * Returns a list of CSS files that will be referenced from the page's 1787 * header relative to the portal's context path. 1788 * 1789 * @return a list of CSS files that will be referenced from the page's 1790 header relative to the portal's context path 1791 */ 1792 @Override 1793 public java.util.List<java.lang.String> getHeaderPortalCss() { 1794 return _portlet.getHeaderPortalCss(); 1795 } 1796 1797 /** 1798 * Returns a list of JavaScript files that will be referenced from the 1799 * page's header relative to the portal's context path. 1800 * 1801 * @return a list of JavaScript files that will be referenced from the 1802 page's header relative to the portal's context path 1803 */ 1804 @Override 1805 public java.util.List<java.lang.String> getHeaderPortalJavaScript() { 1806 return _portlet.getHeaderPortalJavaScript(); 1807 } 1808 1809 /** 1810 * Returns a list of CSS files that will be referenced from the page's 1811 * header relative to the portlet's context path. 1812 * 1813 * @return a list of CSS files that will be referenced from the page's 1814 header relative to the portlet's context path 1815 */ 1816 @Override 1817 public java.util.List<java.lang.String> getHeaderPortletCss() { 1818 return _portlet.getHeaderPortletCss(); 1819 } 1820 1821 /** 1822 * Returns a list of JavaScript files that will be referenced from the 1823 * page's header relative to the portlet's context path. 1824 * 1825 * @return a list of JavaScript files that will be referenced from the 1826 page's header relative to the portlet's context path 1827 */ 1828 @Override 1829 public java.util.List<java.lang.String> getHeaderPortletJavaScript() { 1830 return _portlet.getHeaderPortletJavaScript(); 1831 } 1832 1833 /** 1834 * Returns the names of the classes that represent indexers associated with 1835 * the portlet. 1836 * 1837 * @return the names of the classes that represent indexers associated with 1838 the portlet 1839 */ 1840 @Override 1841 public java.util.List<java.lang.String> getIndexerClasses() { 1842 return _portlet.getIndexerClasses(); 1843 } 1844 1845 /** 1846 * Returns the indexer instances of the portlet. 1847 * 1848 * @return the indexer instances of the portlet 1849 */ 1850 @Override 1851 public java.util.List<com.liferay.portal.kernel.search.Indexer<?>> getIndexerInstances() { 1852 return _portlet.getIndexerInstances(); 1853 } 1854 1855 /** 1856 * Returns the scheduler entries of the portlet. 1857 * 1858 * @return the scheduler entries of the portlet 1859 */ 1860 @Override 1861 public java.util.List<com.liferay.portal.kernel.scheduler.SchedulerEntry> getSchedulerEntries() { 1862 return _portlet.getSchedulerEntries(); 1863 } 1864 1865 /** 1866 * Returns the names of the classes that represent social activity 1867 * interpreters associated with the portlet. 1868 * 1869 * @return the names of the classes that represent social activity 1870 interpreters associated with the portlet 1871 */ 1872 @Override 1873 public java.util.List<java.lang.String> getSocialActivityInterpreterClasses() { 1874 return _portlet.getSocialActivityInterpreterClasses(); 1875 } 1876 1877 /** 1878 * Returns the social activity interpreter instances of the portlet. 1879 * 1880 * @return the social activity interpreter instances of the portlet 1881 */ 1882 @Override 1883 public java.util.List<com.liferay.social.kernel.model.SocialActivityInterpreter> getSocialActivityInterpreterInstances() { 1884 return _portlet.getSocialActivityInterpreterInstances(); 1885 } 1886 1887 /** 1888 * Returns the names of the classes that represent staged model data 1889 * handlers associated with the portlet. 1890 * 1891 * @return the names of the classes that represent staged model data 1892 handlers associated with the portlet 1893 */ 1894 @Override 1895 public java.util.List<java.lang.String> getStagedModelDataHandlerClasses() { 1896 return _portlet.getStagedModelDataHandlerClasses(); 1897 } 1898 1899 /** 1900 * Returns the staged model data handler instances of the portlet. 1901 * 1902 * @return the staged model data handler instances of the portlet 1903 */ 1904 @Override 1905 public java.util.List<com.liferay.exportimport.kernel.lar.StagedModelDataHandler<?>> getStagedModelDataHandlerInstances() { 1906 return _portlet.getStagedModelDataHandlerInstances(); 1907 } 1908 1909 /** 1910 * Returns the names of the classes that represent trash handlers associated 1911 * with the portlet. 1912 * 1913 * @return the names of the classes that represent trash handlers associated 1914 with the portlet 1915 */ 1916 @Override 1917 public java.util.List<java.lang.String> getTrashHandlerClasses() { 1918 return _portlet.getTrashHandlerClasses(); 1919 } 1920 1921 /** 1922 * Returns the trash handler instances of the portlet. 1923 * 1924 * @return the trash handler instances of the portlet 1925 */ 1926 @Override 1927 public java.util.List<com.liferay.portal.kernel.trash.TrashHandler> getTrashHandlerInstances() { 1928 return _portlet.getTrashHandlerInstances(); 1929 } 1930 1931 /** 1932 * Returns the names of the classes that represent user notification 1933 * handlers associated with the portlet. 1934 * 1935 * @return the names of the classes that represent user notification 1936 handlers associated with the portlet 1937 */ 1938 @Override 1939 public java.util.List<java.lang.String> getUserNotificationHandlerClasses() { 1940 return _portlet.getUserNotificationHandlerClasses(); 1941 } 1942 1943 /** 1944 * Returns the user notification handler instances of the portlet. 1945 * 1946 * @return the user notification handler instances of the portlet 1947 */ 1948 @Override 1949 public java.util.List<com.liferay.portal.kernel.notifications.UserNotificationHandler> getUserNotificationHandlerInstances() { 1950 return _portlet.getUserNotificationHandlerInstances(); 1951 } 1952 1953 /** 1954 * Returns the names of the classes that represent workflow handlers 1955 * associated with the portlet. 1956 * 1957 * @return the names of the classes that represent workflow handlers 1958 associated with the portlet 1959 */ 1960 @Override 1961 public java.util.List<java.lang.String> getWorkflowHandlerClasses() { 1962 return _portlet.getWorkflowHandlerClasses(); 1963 } 1964 1965 /** 1966 * Returns the workflow handler instances of the portlet. 1967 * 1968 * @return the workflow handler instances of the portlet 1969 */ 1970 @Override 1971 public java.util.List<com.liferay.portal.kernel.workflow.WorkflowHandler<?>> getWorkflowHandlerInstances() { 1972 return _portlet.getWorkflowHandlerInstances(); 1973 } 1974 1975 /** 1976 * Returns the init parameters of the portlet. 1977 * 1978 * @return init parameters of the portlet 1979 */ 1980 @Override 1981 public Map<java.lang.String, java.lang.String> getInitParams() { 1982 return _portlet.getInitParams(); 1983 } 1984 1985 /** 1986 * Returns the filters of the portlet. 1987 * 1988 * @return filters of the portlet 1989 */ 1990 @Override 1991 public Map<java.lang.String, PortletFilter> getPortletFilters() { 1992 return _portlet.getPortletFilters(); 1993 } 1994 1995 /** 1996 * Returns the portlet modes of the portlet. 1997 * 1998 * @return portlet modes of the portlet 1999 */ 2000 @Override 2001 public Map<java.lang.String, java.util.Set<java.lang.String>> getPortletModes() { 2002 return _portlet.getPortletModes(); 2003 } 2004 2005 /** 2006 * Returns the role mappers of the portlet. 2007 * 2008 * @return role mappers of the portlet 2009 */ 2010 @Override 2011 public Map<java.lang.String, java.lang.String> getRoleMappers() { 2012 return _portlet.getRoleMappers(); 2013 } 2014 2015 /** 2016 * Returns the window states of the portlet. 2017 * 2018 * @return window states of the portlet 2019 */ 2020 @Override 2021 public Map<java.lang.String, java.util.Set<java.lang.String>> getWindowStates() { 2022 return _portlet.getWindowStates(); 2023 } 2024 2025 /** 2026 * Returns the portlet modes of the portlet. 2027 * 2028 * @return the portlet modes of the portlet 2029 */ 2030 @Override 2031 public java.util.Set<java.lang.String> getAllPortletModes() { 2032 return _portlet.getAllPortletModes(); 2033 } 2034 2035 /** 2036 * Returns the window states of the portlet. 2037 * 2038 * @return the window states of the portlet 2039 */ 2040 @Override 2041 public java.util.Set<java.lang.String> getAllWindowStates() { 2042 return _portlet.getAllWindowStates(); 2043 } 2044 2045 /** 2046 * Returns the application types of the portlet. 2047 * 2048 * @return the application types of the portlet 2049 */ 2050 @Override 2051 public java.util.Set<com.liferay.portal.kernel.application.type.ApplicationType> getApplicationTypes() { 2052 return _portlet.getApplicationTypes(); 2053 } 2054 2055 /** 2056 * Returns the names of the parameters that will be automatically propagated 2057 * through the portlet. 2058 * 2059 * @return the names of the parameters that will be automatically propagated 2060 through the portlet 2061 */ 2062 @Override 2063 public java.util.Set<java.lang.String> getAutopropagatedParameters() { 2064 return _portlet.getAutopropagatedParameters(); 2065 } 2066 2067 /** 2068 * Returns the processing events of the portlet. 2069 * 2070 * @return the processing events of the portlet 2071 */ 2072 @Override 2073 public java.util.Set<com.liferay.portal.kernel.xml.QName> getProcessingEvents() { 2074 return _portlet.getProcessingEvents(); 2075 } 2076 2077 /** 2078 * Returns the public render parameters of the portlet. 2079 * 2080 * @return the public render parameters of the portlet 2081 */ 2082 @Override 2083 public java.util.Set<PublicRenderParameter> getPublicRenderParameters() { 2084 return _portlet.getPublicRenderParameters(); 2085 } 2086 2087 /** 2088 * Returns the publishing events of the portlet. 2089 * 2090 * @return the publishing events of the portlet 2091 */ 2092 @Override 2093 public java.util.Set<com.liferay.portal.kernel.xml.QName> getPublishingEvents() { 2094 return _portlet.getPublishingEvents(); 2095 } 2096 2097 /** 2098 * Returns the supported locales of the portlet. 2099 * 2100 * @return the supported locales of the portlet 2101 */ 2102 @Override 2103 public java.util.Set<java.lang.String> getSupportedLocales() { 2104 return _portlet.getSupportedLocales(); 2105 } 2106 2107 /** 2108 * Returns the unlinked roles of the portlet. 2109 * 2110 * @return unlinked roles of the portlet 2111 */ 2112 @Override 2113 public java.util.Set<java.lang.String> getUnlinkedRoles() { 2114 return _portlet.getUnlinkedRoles(); 2115 } 2116 2117 /** 2118 * Returns the company ID of this portlet. 2119 * 2120 * @return the company ID of this portlet 2121 */ 2122 @Override 2123 public long getCompanyId() { 2124 return _portlet.getCompanyId(); 2125 } 2126 2127 /** 2128 * Returns the ID of this portlet. 2129 * 2130 * @return the ID of this portlet 2131 */ 2132 @Override 2133 public long getId() { 2134 return _portlet.getId(); 2135 } 2136 2137 /** 2138 * Returns the mvcc version of this portlet. 2139 * 2140 * @return the mvcc version of this portlet 2141 */ 2142 @Override 2143 public long getMvccVersion() { 2144 return _portlet.getMvccVersion(); 2145 } 2146 2147 /** 2148 * Returns the primary key of this portlet. 2149 * 2150 * @return the primary key of this portlet 2151 */ 2152 @Override 2153 public long getPrimaryKey() { 2154 return _portlet.getPrimaryKey(); 2155 } 2156 2157 /** 2158 * Returns the timestamp of the portlet. 2159 * 2160 * @return the timestamp of the portlet 2161 */ 2162 @Override 2163 public long getTimestamp() { 2164 return _portlet.getTimestamp(); 2165 } 2166 2167 /** 2168 * Returns the user ID of the portlet. This only applies when the portlet is 2169 * added by a user in a customizable layout. 2170 * 2171 * @return the user ID of the portlet 2172 */ 2173 @Override 2174 public long getUserId() { 2175 return _portlet.getUserId(); 2176 } 2177 2178 /** 2179 * Adds an application type. 2180 * 2181 * @param applicationType an application type 2182 */ 2183 @Override 2184 public void addApplicationType( 2185 com.liferay.portal.kernel.application.type.ApplicationType applicationType) { 2186 _portlet.addApplicationType(applicationType); 2187 } 2188 2189 /** 2190 * Adds a processing event. 2191 */ 2192 @Override 2193 public void addProcessingEvent( 2194 com.liferay.portal.kernel.xml.QName processingEvent) { 2195 _portlet.addProcessingEvent(processingEvent); 2196 } 2197 2198 /** 2199 * Adds a public render parameter. 2200 * 2201 * @param publicRenderParameter a public render parameter 2202 */ 2203 @Override 2204 public void addPublicRenderParameter( 2205 PublicRenderParameter publicRenderParameter) { 2206 _portlet.addPublicRenderParameter(publicRenderParameter); 2207 } 2208 2209 /** 2210 * Adds a publishing event. 2211 */ 2212 @Override 2213 public void addPublishingEvent( 2214 com.liferay.portal.kernel.xml.QName publishingEvent) { 2215 _portlet.addPublishingEvent(publishingEvent); 2216 } 2217 2218 /** 2219 * Adds a scheduler entry. 2220 */ 2221 @Override 2222 public void addSchedulerEntry( 2223 com.liferay.portal.kernel.scheduler.SchedulerEntry schedulerEntry) { 2224 _portlet.addSchedulerEntry(schedulerEntry); 2225 } 2226 2227 /** 2228 * Link the role names set in portlet.xml with the Liferay roles set in 2229 * liferay-portlet.xml. 2230 */ 2231 @Override 2232 public void linkRoles() { 2233 _portlet.linkRoles(); 2234 } 2235 2236 @Override 2237 public void persist() { 2238 _portlet.persist(); 2239 } 2240 2241 /** 2242 * Sets the action timeout of the portlet. 2243 * 2244 * @param actionTimeout the action timeout of the portlet 2245 */ 2246 @Override 2247 public void setActionTimeout(int actionTimeout) { 2248 _portlet.setActionTimeout(actionTimeout); 2249 } 2250 2251 /** 2252 * Set to <code>true</code> if an action URL for this portlet should cause 2253 * an auto redirect. 2254 * 2255 * @param actionURLRedirect boolean value for whether an action URL for this 2256 portlet should cause an auto redirect 2257 */ 2258 @Override 2259 public void setActionURLRedirect(boolean actionURLRedirect) { 2260 _portlet.setActionURLRedirect(actionURLRedirect); 2261 } 2262 2263 /** 2264 * Sets whether this portlet is active. 2265 * 2266 * @param active the active of this portlet 2267 */ 2268 @Override 2269 public void setActive(boolean active) { 2270 _portlet.setActive(active); 2271 } 2272 2273 /** 2274 * Set to <code>true</code> if default resources for the portlet are added 2275 * to a page. 2276 * 2277 * @param addDefaultResource boolean value for whether or not default 2278 resources for the portlet are added to a page 2279 */ 2280 @Override 2281 public void setAddDefaultResource(boolean addDefaultResource) { 2282 _portlet.setAddDefaultResource(addDefaultResource); 2283 } 2284 2285 /** 2286 * Set to <code>true</code> if the portlet can be displayed via Ajax. 2287 * 2288 * @param ajaxable boolean value for whether the portlet can be displayed 2289 via Ajax 2290 */ 2291 @Override 2292 public void setAjaxable(boolean ajaxable) { 2293 _portlet.setAjaxable(ajaxable); 2294 } 2295 2296 /** 2297 * Sets the application types of the portlet. 2298 * 2299 * @param applicationTypes the application types of the portlet 2300 */ 2301 @Override 2302 public void setApplicationTypes( 2303 java.util.Set<com.liferay.portal.kernel.application.type.ApplicationType> applicationTypes) { 2304 _portlet.setApplicationTypes(applicationTypes); 2305 } 2306 2307 /** 2308 * Sets the names of the classes that represent asset types associated with 2309 * the portlet. 2310 * 2311 * @param assetRendererFactoryClasses the names of the classes that 2312 represent asset types associated with the portlet 2313 */ 2314 @Override 2315 public void setAssetRendererFactoryClasses( 2316 java.util.List<java.lang.String> assetRendererFactoryClasses) { 2317 _portlet.setAssetRendererFactoryClasses(assetRendererFactoryClasses); 2318 } 2319 2320 /** 2321 * Sets the names of the classes that represent atom collection adapters 2322 * associated with the portlet. 2323 * 2324 * @param atomCollectionAdapterClasses the names of the classes that 2325 represent atom collection adapters associated with the portlet 2326 */ 2327 @Override 2328 public void setAtomCollectionAdapterClasses( 2329 java.util.List<java.lang.String> atomCollectionAdapterClasses) { 2330 _portlet.setAtomCollectionAdapterClasses(atomCollectionAdapterClasses); 2331 } 2332 2333 /** 2334 * Sets the names of the parameters that will be automatically propagated 2335 * through the portlet. 2336 * 2337 * @param autopropagatedParameters the names of the parameters that will be 2338 automatically propagated through the portlet 2339 */ 2340 @Override 2341 public void setAutopropagatedParameters( 2342 java.util.Set<java.lang.String> autopropagatedParameters) { 2343 _portlet.setAutopropagatedParameters(autopropagatedParameters); 2344 } 2345 2346 @Override 2347 public void setCachedModel(boolean cachedModel) { 2348 _portlet.setCachedModel(cachedModel); 2349 } 2350 2351 /** 2352 * Sets the company ID of this portlet. 2353 * 2354 * @param companyId the company ID of this portlet 2355 */ 2356 @Override 2357 public void setCompanyId(long companyId) { 2358 _portlet.setCompanyId(companyId); 2359 } 2360 2361 /** 2362 * Sets the configuration action class of the portlet. 2363 * 2364 * @param configurationActionClass the configuration action class of the 2365 portlet 2366 */ 2367 @Override 2368 public void setConfigurationActionClass( 2369 java.lang.String configurationActionClass) { 2370 _portlet.setConfigurationActionClass(configurationActionClass); 2371 } 2372 2373 /** 2374 * Set the name of the category of the Control Panel where the portlet will 2375 * be shown. 2376 * 2377 * @param controlPanelEntryCategory the name of the category of the Control 2378 Panel where the portlet will be shown 2379 */ 2380 @Override 2381 public void setControlPanelEntryCategory( 2382 java.lang.String controlPanelEntryCategory) { 2383 _portlet.setControlPanelEntryCategory(controlPanelEntryCategory); 2384 } 2385 2386 /** 2387 * Sets the name of the class that will control when the portlet will be 2388 * shown in the Control Panel. 2389 * 2390 * @param controlPanelEntryClass the name of the class that will control 2391 when the portlet will be shown in the Control Panel 2392 */ 2393 @Override 2394 public void setControlPanelEntryClass( 2395 java.lang.String controlPanelEntryClass) { 2396 _portlet.setControlPanelEntryClass(controlPanelEntryClass); 2397 } 2398 2399 /** 2400 * Sets the relative weight of the portlet with respect to the other 2401 * portlets in the same category of the Control Panel. 2402 * 2403 * @param controlPanelEntryWeight the relative weight of the portlet with 2404 respect to the other portlets in the same category of the Control 2405 Panel 2406 */ 2407 @Override 2408 public void setControlPanelEntryWeight(double controlPanelEntryWeight) { 2409 _portlet.setControlPanelEntryWeight(controlPanelEntryWeight); 2410 } 2411 2412 /** 2413 * Sets the name of the CSS class that will be injected in the DIV that 2414 * wraps this portlet. 2415 * 2416 * @param cssClassWrapper the name of the CSS class that will be injected in 2417 the DIV that wraps this portlet 2418 */ 2419 @Override 2420 public void setCssClassWrapper(java.lang.String cssClassWrapper) { 2421 _portlet.setCssClassWrapper(cssClassWrapper); 2422 } 2423 2424 /** 2425 * Sets the names of the classes that represent custom attribute displays 2426 * associated with the portlet. 2427 * 2428 * @param customAttributesDisplayClasses the names of the classes that 2429 represent custom attribute displays associated with the portlet 2430 */ 2431 @Override 2432 public void setCustomAttributesDisplayClasses( 2433 java.util.List<java.lang.String> customAttributesDisplayClasses) { 2434 _portlet.setCustomAttributesDisplayClasses(customAttributesDisplayClasses); 2435 } 2436 2437 /** 2438 * Sets the default plugin settings of the portlet. 2439 * 2440 * @param pluginSetting the plugin setting 2441 */ 2442 @Override 2443 public void setDefaultPluginSetting(PluginSetting pluginSetting) { 2444 _portlet.setDefaultPluginSetting(pluginSetting); 2445 } 2446 2447 /** 2448 * Sets the default preferences of the portlet. 2449 * 2450 * @param defaultPreferences the default preferences of the portlet 2451 */ 2452 @Override 2453 public void setDefaultPreferences(java.lang.String defaultPreferences) { 2454 _portlet.setDefaultPreferences(defaultPreferences); 2455 } 2456 2457 /** 2458 * Sets the display name of the portlet. 2459 * 2460 * @param displayName the display name of the portlet 2461 */ 2462 @Override 2463 public void setDisplayName(java.lang.String displayName) { 2464 _portlet.setDisplayName(displayName); 2465 } 2466 2467 /** 2468 * Sets expiration cache of the portlet. 2469 * 2470 * @param expCache expiration cache of the portlet 2471 */ 2472 @Override 2473 public void setExpCache(java.lang.Integer expCache) { 2474 _portlet.setExpCache(expCache); 2475 } 2476 2477 @Override 2478 public void setExpandoBridgeAttributes(BaseModel<?> baseModel) { 2479 _portlet.setExpandoBridgeAttributes(baseModel); 2480 } 2481 2482 @Override 2483 public void setExpandoBridgeAttributes(ExpandoBridge expandoBridge) { 2484 _portlet.setExpandoBridgeAttributes(expandoBridge); 2485 } 2486 2487 @Override 2488 public void setExpandoBridgeAttributes(ServiceContext serviceContext) { 2489 _portlet.setExpandoBridgeAttributes(serviceContext); 2490 } 2491 2492 /** 2493 * Sets the Facebook integration method of the portlet. 2494 * 2495 * @param facebookIntegration the Facebook integration method of the portlet 2496 */ 2497 @Override 2498 public void setFacebookIntegration(java.lang.String facebookIntegration) { 2499 _portlet.setFacebookIntegration(facebookIntegration); 2500 } 2501 2502 /** 2503 * Sets a list of CSS files that will be referenced from the page's footer 2504 * relative to the portal's context path. 2505 * 2506 * @param footerPortalCss a list of CSS files that will be referenced from 2507 the page's footer relative to the portal's context path 2508 */ 2509 @Override 2510 public void setFooterPortalCss( 2511 java.util.List<java.lang.String> footerPortalCss) { 2512 _portlet.setFooterPortalCss(footerPortalCss); 2513 } 2514 2515 /** 2516 * Sets a list of JavaScript files that will be referenced from the page's 2517 * footer relative to the portal's context path. 2518 * 2519 * @param footerPortalJavaScript a list of JavaScript files that will be 2520 referenced from the page's footer relative to the portal's context 2521 path 2522 */ 2523 @Override 2524 public void setFooterPortalJavaScript( 2525 java.util.List<java.lang.String> footerPortalJavaScript) { 2526 _portlet.setFooterPortalJavaScript(footerPortalJavaScript); 2527 } 2528 2529 /** 2530 * Sets a list of CSS files that will be referenced from the page's footer 2531 * relative to the portlet's context path. 2532 * 2533 * @param footerPortletCss a list of CSS files that will be referenced from 2534 the page's footer relative to the portlet's context path 2535 */ 2536 @Override 2537 public void setFooterPortletCss( 2538 java.util.List<java.lang.String> footerPortletCss) { 2539 _portlet.setFooterPortletCss(footerPortletCss); 2540 } 2541 2542 /** 2543 * Sets a list of JavaScript files that will be referenced from the page's 2544 * footer relative to the portlet's context path. 2545 * 2546 * @param footerPortletJavaScript a list of JavaScript files that will be 2547 referenced from the page's footer relative to the portlet's 2548 context path 2549 */ 2550 @Override 2551 public void setFooterPortletJavaScript( 2552 java.util.List<java.lang.String> footerPortletJavaScript) { 2553 _portlet.setFooterPortletJavaScript(footerPortletJavaScript); 2554 } 2555 2556 /** 2557 * Sets the name of the friendly URL mapper class of the portlet. 2558 * 2559 * @param friendlyURLMapperClass the name of the friendly URL mapper class 2560 of the portlet 2561 */ 2562 @Override 2563 public void setFriendlyURLMapperClass( 2564 java.lang.String friendlyURLMapperClass) { 2565 _portlet.setFriendlyURLMapperClass(friendlyURLMapperClass); 2566 } 2567 2568 /** 2569 * Sets the name of the friendly URL mapping of the portlet. 2570 * 2571 * @param friendlyURLMapping the name of the friendly URL mapping of the 2572 portlet 2573 */ 2574 @Override 2575 public void setFriendlyURLMapping(java.lang.String friendlyURLMapping) { 2576 _portlet.setFriendlyURLMapping(friendlyURLMapping); 2577 } 2578 2579 /** 2580 * Sets the class loader resource path to the friendly URL routes of the 2581 * portlet. 2582 * 2583 * @param friendlyURLRoutes the class loader resource path to the friendly 2584 URL routes of the portlet 2585 */ 2586 @Override 2587 public void setFriendlyURLRoutes(java.lang.String friendlyURLRoutes) { 2588 _portlet.setFriendlyURLRoutes(friendlyURLRoutes); 2589 } 2590 2591 /** 2592 * Sets a list of CSS files that will be referenced from the page's header 2593 * relative to the portal's context path. 2594 * 2595 * @param headerPortalCss a list of CSS files that will be referenced from 2596 the page's header relative to the portal's context path 2597 */ 2598 @Override 2599 public void setHeaderPortalCss( 2600 java.util.List<java.lang.String> headerPortalCss) { 2601 _portlet.setHeaderPortalCss(headerPortalCss); 2602 } 2603 2604 /** 2605 * Sets a list of JavaScript files that will be referenced from the page's 2606 * header relative to the portal's context path. 2607 * 2608 * @param headerPortalJavaScript a list of JavaScript files that will be 2609 referenced from the page's header relative to the portal's context 2610 path 2611 */ 2612 @Override 2613 public void setHeaderPortalJavaScript( 2614 java.util.List<java.lang.String> headerPortalJavaScript) { 2615 _portlet.setHeaderPortalJavaScript(headerPortalJavaScript); 2616 } 2617 2618 /** 2619 * Sets a list of CSS files that will be referenced from the page's header 2620 * relative to the portlet's context path. 2621 * 2622 * @param headerPortletCss a list of CSS files that will be referenced from 2623 the page's header relative to the portlet's context path 2624 */ 2625 @Override 2626 public void setHeaderPortletCss( 2627 java.util.List<java.lang.String> headerPortletCss) { 2628 _portlet.setHeaderPortletCss(headerPortletCss); 2629 } 2630 2631 /** 2632 * Sets a list of JavaScript files that will be referenced from the page's 2633 * header relative to the portlet's context path. 2634 * 2635 * @param headerPortletJavaScript a list of JavaScript files that will be 2636 referenced from the page's header relative to the portlet's 2637 context path 2638 */ 2639 @Override 2640 public void setHeaderPortletJavaScript( 2641 java.util.List<java.lang.String> headerPortletJavaScript) { 2642 _portlet.setHeaderPortletJavaScript(headerPortletJavaScript); 2643 } 2644 2645 /** 2646 * Sets the icon of the portlet. 2647 * 2648 * @param icon the icon of the portlet 2649 */ 2650 @Override 2651 public void setIcon(java.lang.String icon) { 2652 _portlet.setIcon(icon); 2653 } 2654 2655 /** 2656 * Sets the ID of this portlet. 2657 * 2658 * @param id the ID of this portlet 2659 */ 2660 @Override 2661 public void setId(long id) { 2662 _portlet.setId(id); 2663 } 2664 2665 /** 2666 * Set to <code>true</code> to include the portlet and make it available to 2667 * be made active. 2668 * 2669 * @param include boolean value for whether to include the portlet and make 2670 it available to be made active 2671 */ 2672 @Override 2673 public void setInclude(boolean include) { 2674 _portlet.setInclude(include); 2675 } 2676 2677 /** 2678 * Sets the names of the classes that represent indexers associated with the 2679 * portlet. 2680 * 2681 * @param indexerClasses the names of the classes that represent indexers 2682 associated with the portlet 2683 */ 2684 @Override 2685 public void setIndexerClasses( 2686 java.util.List<java.lang.String> indexerClasses) { 2687 _portlet.setIndexerClasses(indexerClasses); 2688 } 2689 2690 /** 2691 * Sets the init parameters of the portlet. 2692 * 2693 * @param initParams the init parameters of the portlet 2694 */ 2695 @Override 2696 public void setInitParams( 2697 Map<java.lang.String, java.lang.String> initParams) { 2698 _portlet.setInitParams(initParams); 2699 } 2700 2701 /** 2702 * Set to <code>true</code> if the portlet can be added multiple times to a 2703 * layout. 2704 * 2705 * @param instanceable boolean value for whether the portlet can be added 2706 multiple times to a layout 2707 */ 2708 @Override 2709 public void setInstanceable(boolean instanceable) { 2710 _portlet.setInstanceable(instanceable); 2711 } 2712 2713 /** 2714 * Set to <code>true</code> to allow the portlet to be cached within the 2715 * layout. 2716 * 2717 * @param layoutCacheable boolean value for whether the portlet can be 2718 cached within the layout 2719 */ 2720 @Override 2721 public void setLayoutCacheable(boolean layoutCacheable) { 2722 _portlet.setLayoutCacheable(layoutCacheable); 2723 } 2724 2725 /** 2726 * Set to <code>true</code> if the portlet goes into the maximized state 2727 * when the user goes into the edit mode. 2728 * 2729 * @param maximizeEdit boolean value for whether the portlet goes into the 2730 maximized state when the user goes into the edit mode 2731 */ 2732 @Override 2733 public void setMaximizeEdit(boolean maximizeEdit) { 2734 _portlet.setMaximizeEdit(maximizeEdit); 2735 } 2736 2737 /** 2738 * Set to <code>true</code> if the portlet goes into the maximized state 2739 * when the user goes into the help mode. 2740 * 2741 * @param maximizeHelp boolean value for whether the portlet goes into the 2742 maximized state when the user goes into the help mode 2743 */ 2744 @Override 2745 public void setMaximizeHelp(boolean maximizeHelp) { 2746 _portlet.setMaximizeHelp(maximizeHelp); 2747 } 2748 2749 /** 2750 * Sets the mvcc version of this portlet. 2751 * 2752 * @param mvccVersion the mvcc version of this portlet 2753 */ 2754 @Override 2755 public void setMvccVersion(long mvccVersion) { 2756 _portlet.setMvccVersion(mvccVersion); 2757 } 2758 2759 @Override 2760 public void setNew(boolean n) { 2761 _portlet.setNew(n); 2762 } 2763 2764 /** 2765 * Sets the name of the open search class of the portlet. 2766 * 2767 * @param openSearchClass the name of the open search class of the portlet 2768 */ 2769 @Override 2770 public void setOpenSearchClass(java.lang.String openSearchClass) { 2771 _portlet.setOpenSearchClass(openSearchClass); 2772 } 2773 2774 /** 2775 * Sets the parent struts path of the portlet. 2776 * 2777 * @param parentStrutsPath the parent struts path of the portlet 2778 */ 2779 @Override 2780 public void setParentStrutsPath(java.lang.String parentStrutsPath) { 2781 _portlet.setParentStrutsPath(parentStrutsPath); 2782 } 2783 2784 /** 2785 * Sets the name of the permission propagator class of the portlet. 2786 */ 2787 @Override 2788 public void setPermissionPropagatorClass( 2789 java.lang.String permissionPropagatorClass) { 2790 _portlet.setPermissionPropagatorClass(permissionPropagatorClass); 2791 } 2792 2793 /** 2794 * Sets this portlet's plugin package. 2795 * 2796 * @param pluginPackage this portlet's plugin package 2797 */ 2798 @Override 2799 public void setPluginPackage( 2800 com.liferay.portal.kernel.plugin.PluginPackage pluginPackage) { 2801 _portlet.setPluginPackage(pluginPackage); 2802 } 2803 2804 /** 2805 * Sets the name of the poller processor class of the portlet. 2806 * 2807 * @param pollerProcessorClass the name of the poller processor class of the 2808 portlet 2809 */ 2810 @Override 2811 public void setPollerProcessorClass(java.lang.String pollerProcessorClass) { 2812 _portlet.setPollerProcessorClass(pollerProcessorClass); 2813 } 2814 2815 /** 2816 * Sets the name of the POP message listener class of the portlet. 2817 * 2818 * @param popMessageListenerClass the name of the POP message listener class 2819 of the portlet 2820 */ 2821 @Override 2822 public void setPopMessageListenerClass( 2823 java.lang.String popMessageListenerClass) { 2824 _portlet.setPopMessageListenerClass(popMessageListenerClass); 2825 } 2826 2827 /** 2828 * Set to <code>true</code> if the portlet goes into the pop up state when 2829 * the user goes into the print mode. 2830 * 2831 * @param popUpPrint boolean value for whether the portlet goes into the pop 2832 up state when the user goes into the print mode 2833 */ 2834 @Override 2835 public void setPopUpPrint(boolean popUpPrint) { 2836 _portlet.setPopUpPrint(popUpPrint); 2837 } 2838 2839 /** 2840 * Sets this portlet's application. 2841 * 2842 * @param portletApp this portlet's application 2843 */ 2844 @Override 2845 public void setPortletApp(PortletApp portletApp) { 2846 _portlet.setPortletApp(portletApp); 2847 } 2848 2849 /** 2850 * Sets the name of the portlet class of the portlet. 2851 * 2852 * @param portletClass the name of the portlet class of the portlet 2853 */ 2854 @Override 2855 public void setPortletClass(java.lang.String portletClass) { 2856 _portlet.setPortletClass(portletClass); 2857 } 2858 2859 /** 2860 * Sets the name of the portlet data handler class of the portlet. 2861 * 2862 * @param portletDataHandlerClass the name of portlet data handler class of 2863 the portlet 2864 */ 2865 @Override 2866 public void setPortletDataHandlerClass( 2867 java.lang.String portletDataHandlerClass) { 2868 _portlet.setPortletDataHandlerClass(portletDataHandlerClass); 2869 } 2870 2871 /** 2872 * Sets the filters of the portlet. 2873 * 2874 * @param portletFilters the filters of the portlet 2875 */ 2876 @Override 2877 public void setPortletFilters( 2878 Map<java.lang.String, PortletFilter> portletFilters) { 2879 _portlet.setPortletFilters(portletFilters); 2880 } 2881 2882 /** 2883 * Sets the portlet ID of this portlet. 2884 * 2885 * @param portletId the portlet ID of this portlet 2886 */ 2887 @Override 2888 public void setPortletId(java.lang.String portletId) { 2889 _portlet.setPortletId(portletId); 2890 } 2891 2892 /** 2893 * Sets the portlet info of the portlet. 2894 * 2895 * @param portletInfo the portlet info of the portlet 2896 */ 2897 @Override 2898 public void setPortletInfo(PortletInfo portletInfo) { 2899 _portlet.setPortletInfo(portletInfo); 2900 } 2901 2902 /** 2903 * Sets the name of the portlet layout listener class of the portlet. 2904 * 2905 * @param portletLayoutListenerClass the name of the portlet layout listener 2906 class of the portlet 2907 */ 2908 @Override 2909 public void setPortletLayoutListenerClass( 2910 java.lang.String portletLayoutListenerClass) { 2911 _portlet.setPortletLayoutListenerClass(portletLayoutListenerClass); 2912 } 2913 2914 /** 2915 * Sets the portlet modes of the portlet. 2916 * 2917 * @param portletModes the portlet modes of the portlet 2918 */ 2919 @Override 2920 public void setPortletModes( 2921 Map<java.lang.String, java.util.Set<java.lang.String>> portletModes) { 2922 _portlet.setPortletModes(portletModes); 2923 } 2924 2925 /** 2926 * Sets the name of the portlet. 2927 * 2928 * @param portletName the name of the portlet 2929 */ 2930 @Override 2931 public void setPortletName(java.lang.String portletName) { 2932 _portlet.setPortletName(portletName); 2933 } 2934 2935 /** 2936 * Sets the name of the portlet URL class of the portlet. 2937 * 2938 * @param portletURLClass the name of the portlet URL class of the portlet 2939 */ 2940 @Override 2941 public void setPortletURLClass(java.lang.String portletURLClass) { 2942 _portlet.setPortletURLClass(portletURLClass); 2943 } 2944 2945 /** 2946 * Set to <code>true</code> if preferences are shared across the entire 2947 * company. 2948 * 2949 * @param preferencesCompanyWide boolean value for whether preferences are 2950 shared across the entire company 2951 */ 2952 @Override 2953 public void setPreferencesCompanyWide(boolean preferencesCompanyWide) { 2954 _portlet.setPreferencesCompanyWide(preferencesCompanyWide); 2955 } 2956 2957 /** 2958 * Set to <code>true</code> if preferences are owned by the group when the 2959 * portlet is shown in a group layout. Set to <code>false</code> if 2960 * preferences are owned by the user at all times. 2961 * 2962 * @param preferencesOwnedByGroup boolean value for whether preferences are 2963 owned by the group when the portlet is shown in a group layout or 2964 preferences are owned by the user at all times 2965 */ 2966 @Override 2967 public void setPreferencesOwnedByGroup(boolean preferencesOwnedByGroup) { 2968 _portlet.setPreferencesOwnedByGroup(preferencesOwnedByGroup); 2969 } 2970 2971 /** 2972 * Set to <code>true</code> if preferences are unique per layout. 2973 * 2974 * @param preferencesUniquePerLayout boolean value for whether preferences 2975 are unique per layout 2976 */ 2977 @Override 2978 public void setPreferencesUniquePerLayout( 2979 boolean preferencesUniquePerLayout) { 2980 _portlet.setPreferencesUniquePerLayout(preferencesUniquePerLayout); 2981 } 2982 2983 /** 2984 * Sets the name of the preferences validator class of the portlet. 2985 * 2986 * @param preferencesValidator the name of the preferences validator class 2987 of the portlet 2988 */ 2989 @Override 2990 public void setPreferencesValidator(java.lang.String preferencesValidator) { 2991 _portlet.setPreferencesValidator(preferencesValidator); 2992 } 2993 2994 /** 2995 * Sets the primary key of this portlet. 2996 * 2997 * @param primaryKey the primary key of this portlet 2998 */ 2999 @Override 3000 public void setPrimaryKey(long primaryKey) { 3001 _portlet.setPrimaryKey(primaryKey); 3002 } 3003 3004 @Override 3005 public void setPrimaryKeyObj(Serializable primaryKeyObj) { 3006 _portlet.setPrimaryKeyObj(primaryKeyObj); 3007 } 3008 3009 /** 3010 * Set to <code>true</code> if the portlet does not share request attributes 3011 * with the portal or portlets from another WAR. 3012 * 3013 * @param privateRequestAttributes boolean value for whether the portlet 3014 shares request attributes with the portal or portlets from another 3015 WAR 3016 */ 3017 @Override 3018 public void setPrivateRequestAttributes(boolean privateRequestAttributes) { 3019 _portlet.setPrivateRequestAttributes(privateRequestAttributes); 3020 } 3021 3022 /** 3023 * Set to <code>true</code> if the portlet does not share session attributes 3024 * with the portal. 3025 * 3026 * @param privateSessionAttributes boolean value for whether the portlet 3027 shares session attributes with the portal 3028 */ 3029 @Override 3030 public void setPrivateSessionAttributes(boolean privateSessionAttributes) { 3031 _portlet.setPrivateSessionAttributes(privateSessionAttributes); 3032 } 3033 3034 /** 3035 * Sets the processing events of the portlet. 3036 * 3037 * @param processingEvents the processing events of the portlet 3038 */ 3039 @Override 3040 public void setProcessingEvents( 3041 java.util.Set<com.liferay.portal.kernel.xml.QName> processingEvents) { 3042 _portlet.setProcessingEvents(processingEvents); 3043 } 3044 3045 /** 3046 * Sets the public render parameters of the portlet. 3047 * 3048 * @param publicRenderParameters the public render parameters of the portlet 3049 */ 3050 @Override 3051 public void setPublicRenderParameters( 3052 java.util.Set<PublicRenderParameter> publicRenderParameters) { 3053 _portlet.setPublicRenderParameters(publicRenderParameters); 3054 } 3055 3056 /** 3057 * Sets the publishing events of the portlet. 3058 * 3059 * @param publishingEvents the publishing events of the portlet 3060 */ 3061 @Override 3062 public void setPublishingEvents( 3063 java.util.Set<com.liferay.portal.kernel.xml.QName> publishingEvents) { 3064 _portlet.setPublishingEvents(publishingEvents); 3065 } 3066 3067 /** 3068 * Set to <code>true</code> if the portlet is ready to be used. 3069 * 3070 * @param ready whether the portlet is ready to be used 3071 */ 3072 @Override 3073 public void setReady(boolean ready) { 3074 _portlet.setReady(ready); 3075 } 3076 3077 /** 3078 * Set to <code>true</code> if the portlet supports remoting 3079 * 3080 * @param remoteable boolean value for whether or not the the portlet 3081 supports remoting 3082 */ 3083 @Override 3084 public void setRemoteable(boolean remoteable) { 3085 _portlet.setRemoteable(remoteable); 3086 } 3087 3088 /** 3089 * Sets the render timeout of the portlet. 3090 * 3091 * @param renderTimeout the render timeout of the portlet 3092 */ 3093 @Override 3094 public void setRenderTimeout(int renderTimeout) { 3095 _portlet.setRenderTimeout(renderTimeout); 3096 } 3097 3098 /** 3099 * Sets the render weight of the portlet. 3100 * 3101 * @param renderWeight int value for the render weight of the portlet 3102 */ 3103 @Override 3104 public void setRenderWeight(int renderWeight) { 3105 _portlet.setRenderWeight(renderWeight); 3106 } 3107 3108 /** 3109 * Set to <code>true</code> if the portlet will only process namespaced 3110 * parameters. 3111 * 3112 * @param requiresNamespacedParameters boolean value for whether the portlet 3113 will only process namespaced parameters 3114 */ 3115 @Override 3116 public void setRequiresNamespacedParameters( 3117 boolean requiresNamespacedParameters) { 3118 _portlet.setRequiresNamespacedParameters(requiresNamespacedParameters); 3119 } 3120 3121 /** 3122 * Sets the resource bundle of the portlet. 3123 * 3124 * @param resourceBundle the resource bundle of the portlet 3125 */ 3126 @Override 3127 public void setResourceBundle(java.lang.String resourceBundle) { 3128 _portlet.setResourceBundle(resourceBundle); 3129 } 3130 3131 /** 3132 * Set to <code>true</code> if the portlet restores to the current view from 3133 * the maximized state. 3134 * 3135 * @param restoreCurrentView boolean value for whether the portlet restores 3136 to the current view from the maximized state 3137 */ 3138 @Override 3139 public void setRestoreCurrentView(boolean restoreCurrentView) { 3140 _portlet.setRestoreCurrentView(restoreCurrentView); 3141 } 3142 3143 /** 3144 * Sets the role mappers of the portlet. 3145 * 3146 * @param roleMappers the role mappers of the portlet 3147 */ 3148 @Override 3149 public void setRoleMappers( 3150 Map<java.lang.String, java.lang.String> roleMappers) { 3151 _portlet.setRoleMappers(roleMappers); 3152 } 3153 3154 /** 3155 * Sets the roles of this portlet. 3156 * 3157 * @param roles the roles of this portlet 3158 */ 3159 @Override 3160 public void setRoles(java.lang.String roles) { 3161 _portlet.setRoles(roles); 3162 } 3163 3164 /** 3165 * Sets an array of required roles of the portlet. 3166 * 3167 * @param rolesArray an array of required roles of the portlet 3168 */ 3169 @Override 3170 public void setRolesArray(java.lang.String[] rolesArray) { 3171 _portlet.setRolesArray(rolesArray); 3172 } 3173 3174 /** 3175 * Sets the scheduler entries of the portlet. 3176 * 3177 * @param schedulerEntries the scheduler entries of the portlet 3178 */ 3179 @Override 3180 public void setSchedulerEntries( 3181 java.util.List<com.liferay.portal.kernel.scheduler.SchedulerEntry> schedulerEntries) { 3182 _portlet.setSchedulerEntries(schedulerEntries); 3183 } 3184 3185 /** 3186 * Set to <code>true</code> if the portlet supports scoping of data. 3187 * 3188 * @param scopeable boolean value for whether or not the the portlet 3189 supports scoping of data 3190 */ 3191 @Override 3192 public void setScopeable(boolean scopeable) { 3193 _portlet.setScopeable(scopeable); 3194 } 3195 3196 /** 3197 * Set to <code>true</code> if users are shown that they do not have access 3198 * to the portlet. 3199 * 3200 * @param showPortletAccessDenied boolean value for whether users are shown 3201 that they do not have access to the portlet 3202 */ 3203 @Override 3204 public void setShowPortletAccessDenied(boolean showPortletAccessDenied) { 3205 _portlet.setShowPortletAccessDenied(showPortletAccessDenied); 3206 } 3207 3208 /** 3209 * Set to <code>true</code> if users are shown that the portlet is inactive. 3210 * 3211 * @param showPortletInactive boolean value for whether users are shown that 3212 the portlet is inactive 3213 */ 3214 @Override 3215 public void setShowPortletInactive(boolean showPortletInactive) { 3216 _portlet.setShowPortletInactive(showPortletInactive); 3217 } 3218 3219 /** 3220 * Set to <code>true</code> if the portlet uses Single Page Application. 3221 * 3222 * @param singlePageApplication boolean value for whether or not the the 3223 portlet uses Single Page Application 3224 */ 3225 @Override 3226 public void setSinglePageApplication(boolean singlePageApplication) { 3227 _portlet.setSinglePageApplication(singlePageApplication); 3228 } 3229 3230 /** 3231 * Sets the names of the classes that represent social activity interpreters 3232 * associated with the portlet. 3233 * 3234 * @param socialActivityInterpreterClasses the names of the classes that 3235 represent social activity interpreters associated with the portlet 3236 */ 3237 @Override 3238 public void setSocialActivityInterpreterClasses( 3239 java.util.List<java.lang.String> socialActivityInterpreterClasses) { 3240 _portlet.setSocialActivityInterpreterClasses(socialActivityInterpreterClasses); 3241 } 3242 3243 /** 3244 * Sets the name of the social request interpreter class of the portlet. 3245 * 3246 * @param socialRequestInterpreterClass the name of the request interpreter 3247 class of the portlet 3248 */ 3249 @Override 3250 public void setSocialRequestInterpreterClass( 3251 java.lang.String socialRequestInterpreterClass) { 3252 _portlet.setSocialRequestInterpreterClass(socialRequestInterpreterClass); 3253 } 3254 3255 /** 3256 * Sets the names of the classes that represent staged model data handlers 3257 * associated with the portlet. 3258 * 3259 * @param stagedModelDataHandlerClasses the names of the classes that 3260 represent staged model data handlers associated with the portlet 3261 */ 3262 @Override 3263 public void setStagedModelDataHandlerClasses( 3264 java.util.List<java.lang.String> stagedModelDataHandlerClasses) { 3265 _portlet.setStagedModelDataHandlerClasses(stagedModelDataHandlerClasses); 3266 } 3267 3268 /** 3269 * Set to <code>true</code> if the portlet is a static portlet that is 3270 * cannot be moved. 3271 * 3272 * @param staticPortlet boolean value for whether the portlet is a static 3273 portlet that cannot be moved 3274 */ 3275 @Override 3276 public void setStatic(boolean staticPortlet) { 3277 _portlet.setStatic(staticPortlet); 3278 } 3279 3280 /** 3281 * Set to <code>true</code> if the portlet is a static portlet at the start 3282 * of a list of portlets. 3283 * 3284 * @param staticPortletStart boolean value for whether the portlet is a 3285 static portlet at the start of a list of portlets 3286 */ 3287 @Override 3288 public void setStaticStart(boolean staticPortletStart) { 3289 _portlet.setStaticStart(staticPortletStart); 3290 } 3291 3292 /** 3293 * Sets the struts path of the portlet. 3294 * 3295 * @param strutsPath the struts path of the portlet 3296 */ 3297 @Override 3298 public void setStrutsPath(java.lang.String strutsPath) { 3299 _portlet.setStrutsPath(strutsPath); 3300 } 3301 3302 /** 3303 * Sets the supported locales of the portlet. 3304 * 3305 * @param supportedLocales the supported locales of the portlet 3306 */ 3307 @Override 3308 public void setSupportedLocales( 3309 java.util.Set<java.lang.String> supportedLocales) { 3310 _portlet.setSupportedLocales(supportedLocales); 3311 } 3312 3313 /** 3314 * Set to <code>true</code> if the portlet is a system portlet that a user 3315 * cannot manually add to their page. 3316 * 3317 * @param system boolean value for whether the portlet is a system portlet 3318 that a user cannot manually add to their page 3319 */ 3320 @Override 3321 public void setSystem(boolean system) { 3322 _portlet.setSystem(system); 3323 } 3324 3325 /** 3326 * Sets the name of the template handler class of the portlet. 3327 * 3328 * @param templateHandlerClass the name of template handler class of the 3329 portlet 3330 */ 3331 @Override 3332 public void setTemplateHandlerClass(java.lang.String templateHandlerClass) { 3333 _portlet.setTemplateHandlerClass(templateHandlerClass); 3334 } 3335 3336 /** 3337 * Sets the names of the classes that represent trash handlers associated to 3338 * the portlet. 3339 * 3340 * @param trashHandlerClasses the names of the classes that represent trash 3341 handlers associated with the portlet 3342 */ 3343 @Override 3344 public void setTrashHandlerClasses( 3345 java.util.List<java.lang.String> trashHandlerClasses) { 3346 _portlet.setTrashHandlerClasses(trashHandlerClasses); 3347 } 3348 3349 /** 3350 * Sets the name of the URL encoder class of the portlet. 3351 * 3352 * @param urlEncoderClass the name of the URL encoder class of the portlet 3353 */ 3354 @Override 3355 public void setURLEncoderClass(java.lang.String urlEncoderClass) { 3356 _portlet.setURLEncoderClass(urlEncoderClass); 3357 } 3358 3359 /** 3360 * Set to <code>true</code> if the portlet is an undeployed portlet. 3361 * 3362 * @param undeployedPortlet boolean value for whether the portlet is an 3363 undeployed portlet 3364 */ 3365 @Override 3366 public void setUndeployedPortlet(boolean undeployedPortlet) { 3367 _portlet.setUndeployedPortlet(undeployedPortlet); 3368 } 3369 3370 /** 3371 * Sets the unlinked roles of the portlet. 3372 * 3373 * @param unlinkedRoles the unlinked roles of the portlet 3374 */ 3375 @Override 3376 public void setUnlinkedRoles(java.util.Set<java.lang.String> unlinkedRoles) { 3377 _portlet.setUnlinkedRoles(unlinkedRoles); 3378 } 3379 3380 /** 3381 * Set to <code>true</code> if the portlet uses the default template. 3382 * 3383 * @param useDefaultTemplate boolean value for whether the portlet uses the 3384 default template 3385 */ 3386 @Override 3387 public void setUseDefaultTemplate(boolean useDefaultTemplate) { 3388 _portlet.setUseDefaultTemplate(useDefaultTemplate); 3389 } 3390 3391 /** 3392 * Sets the class loader resource path to the user notification definitions 3393 * of the portlet. 3394 * 3395 * @param userNotificationDefinitions the class loader resource path to the 3396 user notification definitions of the portlet 3397 */ 3398 @Override 3399 public void setUserNotificationDefinitions( 3400 java.lang.String userNotificationDefinitions) { 3401 _portlet.setUserNotificationDefinitions(userNotificationDefinitions); 3402 } 3403 3404 /** 3405 * Sets the names of the classes that represent user notification handlers 3406 * associated with the portlet. 3407 * 3408 * @param userNotificationHandlerClasses the names of the classes that 3409 represent user notification handlers associated with the portlet 3410 */ 3411 @Override 3412 public void setUserNotificationHandlerClasses( 3413 java.util.List<java.lang.String> userNotificationHandlerClasses) { 3414 _portlet.setUserNotificationHandlerClasses(userNotificationHandlerClasses); 3415 } 3416 3417 /** 3418 * Sets the user principal strategy of the portlet. 3419 * 3420 * @param userPrincipalStrategy the user principal strategy of the portlet 3421 */ 3422 @Override 3423 public void setUserPrincipalStrategy(java.lang.String userPrincipalStrategy) { 3424 _portlet.setUserPrincipalStrategy(userPrincipalStrategy); 3425 } 3426 3427 /** 3428 * Sets the virtual path of the portlet. 3429 * 3430 * @param virtualPath the virtual path of the portlet 3431 */ 3432 @Override 3433 public void setVirtualPath(java.lang.String virtualPath) { 3434 _portlet.setVirtualPath(virtualPath); 3435 } 3436 3437 /** 3438 * Sets the name of the WebDAV storage class of the portlet. 3439 * 3440 * @param webDAVStorageClass the name of the WebDAV storage class of the 3441 portlet 3442 */ 3443 @Override 3444 public void setWebDAVStorageClass(java.lang.String webDAVStorageClass) { 3445 _portlet.setWebDAVStorageClass(webDAVStorageClass); 3446 } 3447 3448 /** 3449 * Sets the name of the WebDAV storage token of the portlet. 3450 * 3451 * @param webDAVStorageToken the name of the WebDAV storage token of the 3452 portlet 3453 */ 3454 @Override 3455 public void setWebDAVStorageToken(java.lang.String webDAVStorageToken) { 3456 _portlet.setWebDAVStorageToken(webDAVStorageToken); 3457 } 3458 3459 /** 3460 * Sets the window states of the portlet. 3461 * 3462 * @param windowStates the window states of the portlet 3463 */ 3464 @Override 3465 public void setWindowStates( 3466 Map<java.lang.String, java.util.Set<java.lang.String>> windowStates) { 3467 _portlet.setWindowStates(windowStates); 3468 } 3469 3470 /** 3471 * Sets the names of the classes that represent workflow handlers associated 3472 * to the portlet. 3473 * 3474 * @param workflowHandlerClasses the names of the classes that represent 3475 workflow handlers associated with the portlet 3476 */ 3477 @Override 3478 public void setWorkflowHandlerClasses( 3479 java.util.List<java.lang.String> workflowHandlerClasses) { 3480 _portlet.setWorkflowHandlerClasses(workflowHandlerClasses); 3481 } 3482 3483 /** 3484 * Sets the name of the XML-RPC method class of the portlet. 3485 * 3486 * @param xmlRpcMethodClass the name of the XML-RPC method class of the 3487 portlet 3488 */ 3489 @Override 3490 public void setXmlRpcMethodClass(java.lang.String xmlRpcMethodClass) { 3491 _portlet.setXmlRpcMethodClass(xmlRpcMethodClass); 3492 } 3493 3494 @Override 3495 public void unsetReady() { 3496 _portlet.unsetReady(); 3497 } 3498 3499 @Override 3500 public boolean equals(Object obj) { 3501 if (this == obj) { 3502 return true; 3503 } 3504 3505 if (!(obj instanceof PortletWrapper)) { 3506 return false; 3507 } 3508 3509 PortletWrapper portletWrapper = (PortletWrapper)obj; 3510 3511 if (Objects.equals(_portlet, portletWrapper._portlet)) { 3512 return true; 3513 } 3514 3515 return false; 3516 } 3517 3518 @Override 3519 public Portlet getWrappedModel() { 3520 return _portlet; 3521 } 3522 3523 @Override 3524 public boolean isEntityCacheEnabled() { 3525 return _portlet.isEntityCacheEnabled(); 3526 } 3527 3528 @Override 3529 public boolean isFinderCacheEnabled() { 3530 return _portlet.isFinderCacheEnabled(); 3531 } 3532 3533 @Override 3534 public void resetOriginalValues() { 3535 _portlet.resetOriginalValues(); 3536 } 3537 3538 private final Portlet _portlet; 3539 }