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