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