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