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