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