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