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