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 java.util.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.portal.kernel.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 java.util.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 java.util.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 java.util.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.portal.kernel.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 java.util.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( 2462 com.liferay.portal.model.BaseModel<?> baseModel) { 2463 _portlet.setExpandoBridgeAttributes(baseModel); 2464 } 2465 2466 @Override 2467 public void setExpandoBridgeAttributes( 2468 com.liferay.portlet.expando.model.ExpandoBridge expandoBridge) { 2469 _portlet.setExpandoBridgeAttributes(expandoBridge); 2470 } 2471 2472 @Override 2473 public void setExpandoBridgeAttributes( 2474 com.liferay.portal.service.ServiceContext serviceContext) { 2475 _portlet.setExpandoBridgeAttributes(serviceContext); 2476 } 2477 2478 /** 2479 * Sets the Facebook integration method of the portlet. 2480 * 2481 * @param facebookIntegration the Facebook integration method of the portlet 2482 */ 2483 @Override 2484 public void setFacebookIntegration(java.lang.String facebookIntegration) { 2485 _portlet.setFacebookIntegration(facebookIntegration); 2486 } 2487 2488 /** 2489 * Sets a list of CSS files that will be referenced from the page's footer 2490 * relative to the portal's context path. 2491 * 2492 * @param footerPortalCss a list of CSS files that will be referenced from 2493 the page's footer relative to the portal's context path 2494 */ 2495 @Override 2496 public void setFooterPortalCss( 2497 java.util.List<java.lang.String> footerPortalCss) { 2498 _portlet.setFooterPortalCss(footerPortalCss); 2499 } 2500 2501 /** 2502 * Sets a list of JavaScript files that will be referenced from the page's 2503 * footer relative to the portal's context path. 2504 * 2505 * @param footerPortalJavaScript a list of JavaScript files that will be 2506 referenced from the page's footer relative to the portal's context 2507 path 2508 */ 2509 @Override 2510 public void setFooterPortalJavaScript( 2511 java.util.List<java.lang.String> footerPortalJavaScript) { 2512 _portlet.setFooterPortalJavaScript(footerPortalJavaScript); 2513 } 2514 2515 /** 2516 * Sets a list of CSS files that will be referenced from the page's footer 2517 * relative to the portlet's context path. 2518 * 2519 * @param footerPortletCss a list of CSS files that will be referenced from 2520 the page's footer relative to the portlet's context path 2521 */ 2522 @Override 2523 public void setFooterPortletCss( 2524 java.util.List<java.lang.String> footerPortletCss) { 2525 _portlet.setFooterPortletCss(footerPortletCss); 2526 } 2527 2528 /** 2529 * Sets a list of JavaScript files that will be referenced from the page's 2530 * footer relative to the portlet's context path. 2531 * 2532 * @param footerPortletJavaScript a list of JavaScript files that will be 2533 referenced from the page's footer relative to the portlet's 2534 context path 2535 */ 2536 @Override 2537 public void setFooterPortletJavaScript( 2538 java.util.List<java.lang.String> footerPortletJavaScript) { 2539 _portlet.setFooterPortletJavaScript(footerPortletJavaScript); 2540 } 2541 2542 /** 2543 * Sets the name of the friendly URL mapper class of the portlet. 2544 * 2545 * @param friendlyURLMapperClass the name of the friendly URL mapper class 2546 of the portlet 2547 */ 2548 @Override 2549 public void setFriendlyURLMapperClass( 2550 java.lang.String friendlyURLMapperClass) { 2551 _portlet.setFriendlyURLMapperClass(friendlyURLMapperClass); 2552 } 2553 2554 /** 2555 * Sets the name of the friendly URL mapping of the portlet. 2556 * 2557 * @param friendlyURLMapping the name of the friendly URL mapping of the 2558 portlet 2559 */ 2560 @Override 2561 public void setFriendlyURLMapping(java.lang.String friendlyURLMapping) { 2562 _portlet.setFriendlyURLMapping(friendlyURLMapping); 2563 } 2564 2565 /** 2566 * Sets the class loader resource path to the friendly URL routes of the 2567 * portlet. 2568 * 2569 * @param friendlyURLRoutes the class loader resource path to the friendly 2570 URL routes of the portlet 2571 */ 2572 @Override 2573 public void setFriendlyURLRoutes(java.lang.String friendlyURLRoutes) { 2574 _portlet.setFriendlyURLRoutes(friendlyURLRoutes); 2575 } 2576 2577 /** 2578 * Sets a list of CSS files that will be referenced from the page's header 2579 * relative to the portal's context path. 2580 * 2581 * @param headerPortalCss a list of CSS files that will be referenced from 2582 the page's header relative to the portal's context path 2583 */ 2584 @Override 2585 public void setHeaderPortalCss( 2586 java.util.List<java.lang.String> headerPortalCss) { 2587 _portlet.setHeaderPortalCss(headerPortalCss); 2588 } 2589 2590 /** 2591 * Sets a list of JavaScript files that will be referenced from the page's 2592 * header relative to the portal's context path. 2593 * 2594 * @param headerPortalJavaScript a list of JavaScript files that will be 2595 referenced from the page's header relative to the portal's context 2596 path 2597 */ 2598 @Override 2599 public void setHeaderPortalJavaScript( 2600 java.util.List<java.lang.String> headerPortalJavaScript) { 2601 _portlet.setHeaderPortalJavaScript(headerPortalJavaScript); 2602 } 2603 2604 /** 2605 * Sets a list of CSS files that will be referenced from the page's header 2606 * relative to the portlet's context path. 2607 * 2608 * @param headerPortletCss a list of CSS files that will be referenced from 2609 the page's header relative to the portlet's context path 2610 */ 2611 @Override 2612 public void setHeaderPortletCss( 2613 java.util.List<java.lang.String> headerPortletCss) { 2614 _portlet.setHeaderPortletCss(headerPortletCss); 2615 } 2616 2617 /** 2618 * Sets a list of JavaScript files that will be referenced from the page's 2619 * header relative to the portlet's context path. 2620 * 2621 * @param headerPortletJavaScript a list of JavaScript files that will be 2622 referenced from the page's header relative to the portlet's 2623 context path 2624 */ 2625 @Override 2626 public void setHeaderPortletJavaScript( 2627 java.util.List<java.lang.String> headerPortletJavaScript) { 2628 _portlet.setHeaderPortletJavaScript(headerPortletJavaScript); 2629 } 2630 2631 /** 2632 * Sets the icon of the portlet. 2633 * 2634 * @param icon the icon of the portlet 2635 */ 2636 @Override 2637 public void setIcon(java.lang.String icon) { 2638 _portlet.setIcon(icon); 2639 } 2640 2641 /** 2642 * Sets the ID of this portlet. 2643 * 2644 * @param id the ID of this portlet 2645 */ 2646 @Override 2647 public void setId(long id) { 2648 _portlet.setId(id); 2649 } 2650 2651 /** 2652 * Set to <code>true</code> to include the portlet and make it available to 2653 * be made active. 2654 * 2655 * @param include boolean value for whether to include the portlet and make 2656 it available to be made active 2657 */ 2658 @Override 2659 public void setInclude(boolean include) { 2660 _portlet.setInclude(include); 2661 } 2662 2663 /** 2664 * Sets the names of the classes that represent indexers associated with the 2665 * portlet. 2666 * 2667 * @param indexerClasses the names of the classes that represent indexers 2668 associated with the portlet 2669 */ 2670 @Override 2671 public void setIndexerClasses( 2672 java.util.List<java.lang.String> indexerClasses) { 2673 _portlet.setIndexerClasses(indexerClasses); 2674 } 2675 2676 /** 2677 * Sets the init parameters of the portlet. 2678 * 2679 * @param initParams the init parameters of the portlet 2680 */ 2681 @Override 2682 public void setInitParams( 2683 java.util.Map<java.lang.String, java.lang.String> initParams) { 2684 _portlet.setInitParams(initParams); 2685 } 2686 2687 /** 2688 * Set to <code>true</code> if the portlet can be added multiple times to a 2689 * layout. 2690 * 2691 * @param instanceable boolean value for whether the portlet can be added 2692 multiple times to a layout 2693 */ 2694 @Override 2695 public void setInstanceable(boolean instanceable) { 2696 _portlet.setInstanceable(instanceable); 2697 } 2698 2699 /** 2700 * Set to <code>true</code> to allow the portlet to be cached within the 2701 * layout. 2702 * 2703 * @param layoutCacheable boolean value for whether the portlet can be 2704 cached within the layout 2705 */ 2706 @Override 2707 public void setLayoutCacheable(boolean layoutCacheable) { 2708 _portlet.setLayoutCacheable(layoutCacheable); 2709 } 2710 2711 /** 2712 * Set to <code>true</code> if the portlet goes into the maximized state 2713 * when the user goes into the edit mode. 2714 * 2715 * @param maximizeEdit boolean value for whether the portlet goes into the 2716 maximized state when the user goes into the edit mode 2717 */ 2718 @Override 2719 public void setMaximizeEdit(boolean maximizeEdit) { 2720 _portlet.setMaximizeEdit(maximizeEdit); 2721 } 2722 2723 /** 2724 * Set to <code>true</code> if the portlet goes into the maximized state 2725 * when the user goes into the help mode. 2726 * 2727 * @param maximizeHelp boolean value for whether the portlet goes into the 2728 maximized state when the user goes into the help mode 2729 */ 2730 @Override 2731 public void setMaximizeHelp(boolean maximizeHelp) { 2732 _portlet.setMaximizeHelp(maximizeHelp); 2733 } 2734 2735 /** 2736 * Sets the mvcc version of this portlet. 2737 * 2738 * @param mvccVersion the mvcc version of this portlet 2739 */ 2740 @Override 2741 public void setMvccVersion(long mvccVersion) { 2742 _portlet.setMvccVersion(mvccVersion); 2743 } 2744 2745 @Override 2746 public void setNew(boolean n) { 2747 _portlet.setNew(n); 2748 } 2749 2750 /** 2751 * Sets the name of the open search class of the portlet. 2752 * 2753 * @param openSearchClass the name of the open search class of the portlet 2754 */ 2755 @Override 2756 public void setOpenSearchClass(java.lang.String openSearchClass) { 2757 _portlet.setOpenSearchClass(openSearchClass); 2758 } 2759 2760 /** 2761 * Sets the parent struts path of the portlet. 2762 * 2763 * @param parentStrutsPath the parent struts path of the portlet 2764 */ 2765 @Override 2766 public void setParentStrutsPath(java.lang.String parentStrutsPath) { 2767 _portlet.setParentStrutsPath(parentStrutsPath); 2768 } 2769 2770 /** 2771 * Sets the name of the permission propagator class of the portlet. 2772 */ 2773 @Override 2774 public void setPermissionPropagatorClass( 2775 java.lang.String permissionPropagatorClass) { 2776 _portlet.setPermissionPropagatorClass(permissionPropagatorClass); 2777 } 2778 2779 /** 2780 * Sets this portlet's plugin package. 2781 * 2782 * @param pluginPackage this portlet's plugin package 2783 */ 2784 @Override 2785 public void setPluginPackage( 2786 com.liferay.portal.kernel.plugin.PluginPackage pluginPackage) { 2787 _portlet.setPluginPackage(pluginPackage); 2788 } 2789 2790 /** 2791 * Sets the name of the poller processor class of the portlet. 2792 * 2793 * @param pollerProcessorClass the name of the poller processor class of the 2794 portlet 2795 */ 2796 @Override 2797 public void setPollerProcessorClass(java.lang.String pollerProcessorClass) { 2798 _portlet.setPollerProcessorClass(pollerProcessorClass); 2799 } 2800 2801 /** 2802 * Sets the name of the POP message listener class of the portlet. 2803 * 2804 * @param popMessageListenerClass the name of the POP message listener class 2805 of the portlet 2806 */ 2807 @Override 2808 public void setPopMessageListenerClass( 2809 java.lang.String popMessageListenerClass) { 2810 _portlet.setPopMessageListenerClass(popMessageListenerClass); 2811 } 2812 2813 /** 2814 * Set to <code>true</code> if the portlet goes into the pop up state when 2815 * the user goes into the print mode. 2816 * 2817 * @param popUpPrint boolean value for whether the portlet goes into the pop 2818 up state when the user goes into the print mode 2819 */ 2820 @Override 2821 public void setPopUpPrint(boolean popUpPrint) { 2822 _portlet.setPopUpPrint(popUpPrint); 2823 } 2824 2825 /** 2826 * Sets this portlet's application. 2827 * 2828 * @param portletApp this portlet's application 2829 */ 2830 @Override 2831 public void setPortletApp(com.liferay.portal.model.PortletApp portletApp) { 2832 _portlet.setPortletApp(portletApp); 2833 } 2834 2835 /** 2836 * Sets the name of the portlet class of the portlet. 2837 * 2838 * @param portletClass the name of the portlet class of the portlet 2839 */ 2840 @Override 2841 public void setPortletClass(java.lang.String portletClass) { 2842 _portlet.setPortletClass(portletClass); 2843 } 2844 2845 /** 2846 * Sets the name of the portlet data handler class of the portlet. 2847 * 2848 * @param portletDataHandlerClass the name of portlet data handler class of 2849 the portlet 2850 */ 2851 @Override 2852 public void setPortletDataHandlerClass( 2853 java.lang.String portletDataHandlerClass) { 2854 _portlet.setPortletDataHandlerClass(portletDataHandlerClass); 2855 } 2856 2857 /** 2858 * Sets the filters of the portlet. 2859 * 2860 * @param portletFilters the filters of the portlet 2861 */ 2862 @Override 2863 public void setPortletFilters( 2864 java.util.Map<java.lang.String, com.liferay.portal.model.PortletFilter> portletFilters) { 2865 _portlet.setPortletFilters(portletFilters); 2866 } 2867 2868 /** 2869 * Sets the portlet ID of this portlet. 2870 * 2871 * @param portletId the portlet ID of this portlet 2872 */ 2873 @Override 2874 public void setPortletId(java.lang.String portletId) { 2875 _portlet.setPortletId(portletId); 2876 } 2877 2878 /** 2879 * Sets the portlet info of the portlet. 2880 * 2881 * @param portletInfo the portlet info of the portlet 2882 */ 2883 @Override 2884 public void setPortletInfo(com.liferay.portal.model.PortletInfo portletInfo) { 2885 _portlet.setPortletInfo(portletInfo); 2886 } 2887 2888 /** 2889 * Sets the name of the portlet layout listener class of the portlet. 2890 * 2891 * @param portletLayoutListenerClass the name of the portlet layout listener 2892 class of the portlet 2893 */ 2894 @Override 2895 public void setPortletLayoutListenerClass( 2896 java.lang.String portletLayoutListenerClass) { 2897 _portlet.setPortletLayoutListenerClass(portletLayoutListenerClass); 2898 } 2899 2900 /** 2901 * Sets the portlet modes of the portlet. 2902 * 2903 * @param portletModes the portlet modes of the portlet 2904 */ 2905 @Override 2906 public void setPortletModes( 2907 java.util.Map<java.lang.String, java.util.Set<java.lang.String>> portletModes) { 2908 _portlet.setPortletModes(portletModes); 2909 } 2910 2911 /** 2912 * Sets the name of the portlet. 2913 * 2914 * @param portletName the name of the portlet 2915 */ 2916 @Override 2917 public void setPortletName(java.lang.String portletName) { 2918 _portlet.setPortletName(portletName); 2919 } 2920 2921 /** 2922 * Sets the name of the portlet URL class of the portlet. 2923 * 2924 * @param portletURLClass the name of the portlet URL class of the portlet 2925 */ 2926 @Override 2927 public void setPortletURLClass(java.lang.String portletURLClass) { 2928 _portlet.setPortletURLClass(portletURLClass); 2929 } 2930 2931 /** 2932 * Set to <code>true</code> if preferences are shared across the entire 2933 * company. 2934 * 2935 * @param preferencesCompanyWide boolean value for whether preferences are 2936 shared across the entire company 2937 */ 2938 @Override 2939 public void setPreferencesCompanyWide(boolean preferencesCompanyWide) { 2940 _portlet.setPreferencesCompanyWide(preferencesCompanyWide); 2941 } 2942 2943 /** 2944 * Set to <code>true</code> if preferences are owned by the group when the 2945 * portlet is shown in a group layout. Set to <code>false</code> if 2946 * preferences are owned by the user at all times. 2947 * 2948 * @param preferencesOwnedByGroup boolean value for whether preferences are 2949 owned by the group when the portlet is shown in a group layout or 2950 preferences are owned by the user at all times 2951 */ 2952 @Override 2953 public void setPreferencesOwnedByGroup(boolean preferencesOwnedByGroup) { 2954 _portlet.setPreferencesOwnedByGroup(preferencesOwnedByGroup); 2955 } 2956 2957 /** 2958 * Set to <code>true</code> if preferences are unique per layout. 2959 * 2960 * @param preferencesUniquePerLayout boolean value for whether preferences 2961 are unique per layout 2962 */ 2963 @Override 2964 public void setPreferencesUniquePerLayout( 2965 boolean preferencesUniquePerLayout) { 2966 _portlet.setPreferencesUniquePerLayout(preferencesUniquePerLayout); 2967 } 2968 2969 /** 2970 * Sets the name of the preferences validator class of the portlet. 2971 * 2972 * @param preferencesValidator the name of the preferences validator class 2973 of the portlet 2974 */ 2975 @Override 2976 public void setPreferencesValidator(java.lang.String preferencesValidator) { 2977 _portlet.setPreferencesValidator(preferencesValidator); 2978 } 2979 2980 /** 2981 * Sets the primary key of this portlet. 2982 * 2983 * @param primaryKey the primary key of this portlet 2984 */ 2985 @Override 2986 public void setPrimaryKey(long primaryKey) { 2987 _portlet.setPrimaryKey(primaryKey); 2988 } 2989 2990 @Override 2991 public void setPrimaryKeyObj(java.io.Serializable primaryKeyObj) { 2992 _portlet.setPrimaryKeyObj(primaryKeyObj); 2993 } 2994 2995 /** 2996 * Set to <code>true</code> if the portlet does not share request attributes 2997 * with the portal or portlets from another WAR. 2998 * 2999 * @param privateRequestAttributes boolean value for whether the portlet 3000 shares request attributes with the portal or portlets from another 3001 WAR 3002 */ 3003 @Override 3004 public void setPrivateRequestAttributes(boolean privateRequestAttributes) { 3005 _portlet.setPrivateRequestAttributes(privateRequestAttributes); 3006 } 3007 3008 /** 3009 * Set to <code>true</code> if the portlet does not share session attributes 3010 * with the portal. 3011 * 3012 * @param privateSessionAttributes boolean value for whether the portlet 3013 shares session attributes with the portal 3014 */ 3015 @Override 3016 public void setPrivateSessionAttributes(boolean privateSessionAttributes) { 3017 _portlet.setPrivateSessionAttributes(privateSessionAttributes); 3018 } 3019 3020 /** 3021 * Sets the supported processing events of the portlet. 3022 * 3023 * @param processingEvents the supported processing events of the portlet 3024 */ 3025 @Override 3026 public void setProcessingEvents( 3027 java.util.Set<com.liferay.portal.kernel.xml.QName> processingEvents) { 3028 _portlet.setProcessingEvents(processingEvents); 3029 } 3030 3031 /** 3032 * Sets the supported public render parameters of the portlet. 3033 * 3034 * @param publicRenderParameters the supported public render parameters of 3035 the portlet 3036 */ 3037 @Override 3038 public void setPublicRenderParameters( 3039 java.util.Set<com.liferay.portal.model.PublicRenderParameter> publicRenderParameters) { 3040 _portlet.setPublicRenderParameters(publicRenderParameters); 3041 } 3042 3043 /** 3044 * Sets the supported publishing events of the portlet. 3045 * 3046 * @param publishingEvents the supported publishing events of the portlet 3047 */ 3048 @Override 3049 public void setPublishingEvents( 3050 java.util.Set<com.liferay.portal.kernel.xml.QName> publishingEvents) { 3051 _portlet.setPublishingEvents(publishingEvents); 3052 } 3053 3054 /** 3055 * Set to <code>true</code> if the portlet is ready to be used. 3056 * 3057 * @param ready whether the portlet is ready to be used 3058 */ 3059 @Override 3060 public void setReady(boolean ready) { 3061 _portlet.setReady(ready); 3062 } 3063 3064 /** 3065 * Set to <code>true</code> if the portlet supports remoting 3066 * 3067 * @param remoteable boolean value for whether or not the the portlet 3068 supports remoting 3069 */ 3070 @Override 3071 public void setRemoteable(boolean remoteable) { 3072 _portlet.setRemoteable(remoteable); 3073 } 3074 3075 /** 3076 * Sets the render timeout of the portlet. 3077 * 3078 * @param renderTimeout the render timeout of the portlet 3079 */ 3080 @Override 3081 public void setRenderTimeout(int renderTimeout) { 3082 _portlet.setRenderTimeout(renderTimeout); 3083 } 3084 3085 /** 3086 * Sets the render weight of the portlet. 3087 * 3088 * @param renderWeight int value for the render weight of the portlet 3089 */ 3090 @Override 3091 public void setRenderWeight(int renderWeight) { 3092 _portlet.setRenderWeight(renderWeight); 3093 } 3094 3095 /** 3096 * Set to <code>true</code> if the portlet will only process namespaced 3097 * parameters. 3098 * 3099 * @param requiresNamespacedParameters boolean value for whether the portlet 3100 will only process namespaced parameters 3101 */ 3102 @Override 3103 public void setRequiresNamespacedParameters( 3104 boolean requiresNamespacedParameters) { 3105 _portlet.setRequiresNamespacedParameters(requiresNamespacedParameters); 3106 } 3107 3108 /** 3109 * Sets the resource bundle of the portlet. 3110 * 3111 * @param resourceBundle the resource bundle of the portlet 3112 */ 3113 @Override 3114 public void setResourceBundle(java.lang.String resourceBundle) { 3115 _portlet.setResourceBundle(resourceBundle); 3116 } 3117 3118 /** 3119 * Set to <code>true</code> if the portlet restores to the current view from 3120 * the maximized state. 3121 * 3122 * @param restoreCurrentView boolean value for whether the portlet restores 3123 to the current view from the maximized state 3124 */ 3125 @Override 3126 public void setRestoreCurrentView(boolean restoreCurrentView) { 3127 _portlet.setRestoreCurrentView(restoreCurrentView); 3128 } 3129 3130 /** 3131 * Sets the role mappers of the portlet. 3132 * 3133 * @param roleMappers the role mappers of the portlet 3134 */ 3135 @Override 3136 public void setRoleMappers( 3137 java.util.Map<java.lang.String, java.lang.String> roleMappers) { 3138 _portlet.setRoleMappers(roleMappers); 3139 } 3140 3141 /** 3142 * Sets the roles of this portlet. 3143 * 3144 * @param roles the roles of this portlet 3145 */ 3146 @Override 3147 public void setRoles(java.lang.String roles) { 3148 _portlet.setRoles(roles); 3149 } 3150 3151 /** 3152 * Sets an array of required roles of the portlet. 3153 * 3154 * @param rolesArray an array of required roles of the portlet 3155 */ 3156 @Override 3157 public void setRolesArray(java.lang.String[] rolesArray) { 3158 _portlet.setRolesArray(rolesArray); 3159 } 3160 3161 /** 3162 * Sets the scheduler entries of the portlet. 3163 * 3164 * @param schedulerEntries the scheduler entries of the portlet 3165 */ 3166 @Override 3167 public void setSchedulerEntries( 3168 java.util.List<com.liferay.portal.kernel.scheduler.SchedulerEntry> schedulerEntries) { 3169 _portlet.setSchedulerEntries(schedulerEntries); 3170 } 3171 3172 /** 3173 * Set to <code>true</code> if the portlet supports scoping of data. 3174 * 3175 * @param scopeable boolean value for whether or not the the portlet 3176 supports scoping of data 3177 */ 3178 @Override 3179 public void setScopeable(boolean scopeable) { 3180 _portlet.setScopeable(scopeable); 3181 } 3182 3183 /** 3184 * Set to <code>true</code> if users are shown that they do not have access 3185 * to the portlet. 3186 * 3187 * @param showPortletAccessDenied boolean value for whether users are shown 3188 that they do not have access to the portlet 3189 */ 3190 @Override 3191 public void setShowPortletAccessDenied(boolean showPortletAccessDenied) { 3192 _portlet.setShowPortletAccessDenied(showPortletAccessDenied); 3193 } 3194 3195 /** 3196 * Set to <code>true</code> if users are shown that the portlet is inactive. 3197 * 3198 * @param showPortletInactive boolean value for whether users are shown that 3199 the portlet is inactive 3200 */ 3201 @Override 3202 public void setShowPortletInactive(boolean showPortletInactive) { 3203 _portlet.setShowPortletInactive(showPortletInactive); 3204 } 3205 3206 /** 3207 * Set to <code>true</code> if the portlet uses Single Page Application. 3208 * 3209 * @param singlePageApplication boolean value for whether or not the the 3210 portlet uses Single Page Application 3211 */ 3212 @Override 3213 public void setSinglePageApplication(boolean singlePageApplication) { 3214 _portlet.setSinglePageApplication(singlePageApplication); 3215 } 3216 3217 /** 3218 * Sets the names of the classes that represent social activity interpreters 3219 * associated with the portlet. 3220 * 3221 * @param socialActivityInterpreterClasses the names of the classes that 3222 represent social activity interpreters associated with the portlet 3223 */ 3224 @Override 3225 public void setSocialActivityInterpreterClasses( 3226 java.util.List<java.lang.String> socialActivityInterpreterClasses) { 3227 _portlet.setSocialActivityInterpreterClasses(socialActivityInterpreterClasses); 3228 } 3229 3230 @Override 3231 public void setSocialInteractionsConfiguration( 3232 boolean socialInteractionsConfiguration) { 3233 _portlet.setSocialInteractionsConfiguration(socialInteractionsConfiguration); 3234 } 3235 3236 /** 3237 * Sets the name of the social request interpreter class of the portlet. 3238 * 3239 * @param socialRequestInterpreterClass the name of the request interpreter 3240 class of the portlet 3241 */ 3242 @Override 3243 public void setSocialRequestInterpreterClass( 3244 java.lang.String socialRequestInterpreterClass) { 3245 _portlet.setSocialRequestInterpreterClass(socialRequestInterpreterClass); 3246 } 3247 3248 /** 3249 * Sets the names of the classes that represent staged model data handlers 3250 * associated with the portlet. 3251 * 3252 * @param stagedModelDataHandlerClasses the names of the classes that 3253 represent staged model data handlers associated with the portlet 3254 */ 3255 @Override 3256 public void setStagedModelDataHandlerClasses( 3257 java.util.List<java.lang.String> stagedModelDataHandlerClasses) { 3258 _portlet.setStagedModelDataHandlerClasses(stagedModelDataHandlerClasses); 3259 } 3260 3261 /** 3262 * Set to <code>true</code> if the portlet is a static portlet that is 3263 * cannot be moved. 3264 * 3265 * @param staticPortlet boolean value for whether the portlet is a static 3266 portlet that cannot be moved 3267 */ 3268 @Override 3269 public void setStatic(boolean staticPortlet) { 3270 _portlet.setStatic(staticPortlet); 3271 } 3272 3273 /** 3274 * Set to <code>true</code> if the portlet is a static portlet at the start 3275 * of a list of portlets. 3276 * 3277 * @param staticPortletStart boolean value for whether the portlet is a 3278 static portlet at the start of a list of portlets 3279 */ 3280 @Override 3281 public void setStaticStart(boolean staticPortletStart) { 3282 _portlet.setStaticStart(staticPortletStart); 3283 } 3284 3285 /** 3286 * Sets the struts path of the portlet. 3287 * 3288 * @param strutsPath the struts path of the portlet 3289 */ 3290 @Override 3291 public void setStrutsPath(java.lang.String strutsPath) { 3292 _portlet.setStrutsPath(strutsPath); 3293 } 3294 3295 /** 3296 * Sets the supported locales of the portlet. 3297 * 3298 * @param supportedLocales the supported locales of the portlet 3299 */ 3300 @Override 3301 public void setSupportedLocales( 3302 java.util.Set<java.lang.String> supportedLocales) { 3303 _portlet.setSupportedLocales(supportedLocales); 3304 } 3305 3306 /** 3307 * Set to <code>true</code> if the portlet is a system portlet that a user 3308 * cannot manually add to their page. 3309 * 3310 * @param system boolean value for whether the portlet is a system portlet 3311 that a user cannot manually add to their page 3312 */ 3313 @Override 3314 public void setSystem(boolean system) { 3315 _portlet.setSystem(system); 3316 } 3317 3318 /** 3319 * Sets the name of the template handler class of the portlet. 3320 * 3321 * @param templateHandlerClass the name of template handler class of the 3322 portlet 3323 */ 3324 @Override 3325 public void setTemplateHandlerClass(java.lang.String templateHandlerClass) { 3326 _portlet.setTemplateHandlerClass(templateHandlerClass); 3327 } 3328 3329 /** 3330 * Sets the names of the classes that represent trash handlers associated to 3331 * the portlet. 3332 * 3333 * @param trashHandlerClasses the names of the classes that represent trash 3334 handlers associated with the portlet 3335 */ 3336 @Override 3337 public void setTrashHandlerClasses( 3338 java.util.List<java.lang.String> trashHandlerClasses) { 3339 _portlet.setTrashHandlerClasses(trashHandlerClasses); 3340 } 3341 3342 /** 3343 * Sets the name of the URL encoder class of the portlet. 3344 * 3345 * @param urlEncoderClass the name of the URL encoder class of the portlet 3346 */ 3347 @Override 3348 public void setURLEncoderClass(java.lang.String urlEncoderClass) { 3349 _portlet.setURLEncoderClass(urlEncoderClass); 3350 } 3351 3352 /** 3353 * Set to <code>true</code> if the portlet is an undeployed portlet. 3354 * 3355 * @param undeployedPortlet boolean value for whether the portlet is an 3356 undeployed portlet 3357 */ 3358 @Override 3359 public void setUndeployedPortlet(boolean undeployedPortlet) { 3360 _portlet.setUndeployedPortlet(undeployedPortlet); 3361 } 3362 3363 /** 3364 * Sets the unlinked roles of the portlet. 3365 * 3366 * @param unlinkedRoles the unlinked roles of the portlet 3367 */ 3368 @Override 3369 public void setUnlinkedRoles(java.util.Set<java.lang.String> unlinkedRoles) { 3370 _portlet.setUnlinkedRoles(unlinkedRoles); 3371 } 3372 3373 /** 3374 * Set to <code>true</code> if the portlet uses the default template. 3375 * 3376 * @param useDefaultTemplate boolean value for whether the portlet uses the 3377 default template 3378 */ 3379 @Override 3380 public void setUseDefaultTemplate(boolean useDefaultTemplate) { 3381 _portlet.setUseDefaultTemplate(useDefaultTemplate); 3382 } 3383 3384 /** 3385 * Sets the class loader resource path to the user notification definitions 3386 * of the portlet. 3387 * 3388 * @param userNotificationDefinitions the class loader resource path to the 3389 user notification definitions of the portlet 3390 */ 3391 @Override 3392 public void setUserNotificationDefinitions( 3393 java.lang.String userNotificationDefinitions) { 3394 _portlet.setUserNotificationDefinitions(userNotificationDefinitions); 3395 } 3396 3397 /** 3398 * Sets the names of the classes that represent user notification handlers 3399 * associated with the portlet. 3400 * 3401 * @param userNotificationHandlerClasses the names of the classes that 3402 represent user notification handlers associated with the portlet 3403 */ 3404 @Override 3405 public void setUserNotificationHandlerClasses( 3406 java.util.List<java.lang.String> userNotificationHandlerClasses) { 3407 _portlet.setUserNotificationHandlerClasses(userNotificationHandlerClasses); 3408 } 3409 3410 /** 3411 * Sets the user principal strategy of the portlet. 3412 * 3413 * @param userPrincipalStrategy the user principal strategy of the portlet 3414 */ 3415 @Override 3416 public void setUserPrincipalStrategy(java.lang.String userPrincipalStrategy) { 3417 _portlet.setUserPrincipalStrategy(userPrincipalStrategy); 3418 } 3419 3420 /** 3421 * Sets the virtual path of the portlet. 3422 * 3423 * @param virtualPath the virtual path of the portlet 3424 */ 3425 @Override 3426 public void setVirtualPath(java.lang.String virtualPath) { 3427 _portlet.setVirtualPath(virtualPath); 3428 } 3429 3430 /** 3431 * Sets the name of the WebDAV storage class of the portlet. 3432 * 3433 * @param webDAVStorageClass the name of the WebDAV storage class of the 3434 portlet 3435 */ 3436 @Override 3437 public void setWebDAVStorageClass(java.lang.String webDAVStorageClass) { 3438 _portlet.setWebDAVStorageClass(webDAVStorageClass); 3439 } 3440 3441 /** 3442 * Sets the name of the WebDAV storage token of the portlet. 3443 * 3444 * @param webDAVStorageToken the name of the WebDAV storage token of the 3445 portlet 3446 */ 3447 @Override 3448 public void setWebDAVStorageToken(java.lang.String webDAVStorageToken) { 3449 _portlet.setWebDAVStorageToken(webDAVStorageToken); 3450 } 3451 3452 /** 3453 * Sets the window states of the portlet. 3454 * 3455 * @param windowStates the window states of the portlet 3456 */ 3457 @Override 3458 public void setWindowStates( 3459 java.util.Map<java.lang.String, java.util.Set<java.lang.String>> windowStates) { 3460 _portlet.setWindowStates(windowStates); 3461 } 3462 3463 /** 3464 * Sets the names of the classes that represent workflow handlers associated 3465 * to the portlet. 3466 * 3467 * @param workflowHandlerClasses the names of the classes that represent 3468 workflow handlers associated with the portlet 3469 */ 3470 @Override 3471 public void setWorkflowHandlerClasses( 3472 java.util.List<java.lang.String> workflowHandlerClasses) { 3473 _portlet.setWorkflowHandlerClasses(workflowHandlerClasses); 3474 } 3475 3476 /** 3477 * Sets the name of the XML-RPC method class of the portlet. 3478 * 3479 * @param xmlRpcMethodClass the name of the XML-RPC method class of the 3480 portlet 3481 */ 3482 @Override 3483 public void setXmlRpcMethodClass(java.lang.String xmlRpcMethodClass) { 3484 _portlet.setXmlRpcMethodClass(xmlRpcMethodClass); 3485 } 3486 3487 @Override 3488 public com.liferay.portal.model.CacheModel<com.liferay.portal.model.Portlet> toCacheModel() { 3489 return _portlet.toCacheModel(); 3490 } 3491 3492 @Override 3493 public com.liferay.portal.model.Portlet toEscapedModel() { 3494 return new PortletWrapper(_portlet.toEscapedModel()); 3495 } 3496 3497 @Override 3498 public java.lang.String toString() { 3499 return _portlet.toString(); 3500 } 3501 3502 @Override 3503 public com.liferay.portal.model.Portlet toUnescapedModel() { 3504 return new PortletWrapper(_portlet.toUnescapedModel()); 3505 } 3506 3507 @Override 3508 public java.lang.String toXmlString() { 3509 return _portlet.toXmlString(); 3510 } 3511 3512 @Override 3513 public boolean equals(Object obj) { 3514 if (this == obj) { 3515 return true; 3516 } 3517 3518 if (!(obj instanceof PortletWrapper)) { 3519 return false; 3520 } 3521 3522 PortletWrapper portletWrapper = (PortletWrapper)obj; 3523 3524 if (Validator.equals(_portlet, portletWrapper._portlet)) { 3525 return true; 3526 } 3527 3528 return false; 3529 } 3530 3531 /** 3532 * @deprecated As of 6.1.0, replaced by {@link #getWrappedModel} 3533 */ 3534 @Deprecated 3535 public Portlet getWrappedPortlet() { 3536 return _portlet; 3537 } 3538 3539 @Override 3540 public Portlet getWrappedModel() { 3541 return _portlet; 3542 } 3543 3544 @Override 3545 public boolean isEntityCacheEnabled() { 3546 return _portlet.isEntityCacheEnabled(); 3547 } 3548 3549 @Override 3550 public boolean isFinderCacheEnabled() { 3551 return _portlet.isFinderCacheEnabled(); 3552 } 3553 3554 @Override 3555 public void resetOriginalValues() { 3556 _portlet.resetOriginalValues(); 3557 } 3558 3559 private final Portlet _portlet; 3560 }