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