1 /**************************************************************************** 2 Copyright (c) 2011-2012 cocos2d-x.org 3 Copyright (c) 2013-2014 Chukong Technologies Inc. 4 5 http://www.cocos2d-x.org 6 7 Permission is hereby granted, free of charge, to any person obtaining a copy 8 of this software and associated documentation files (the "Software"), to deal 9 in the Software without restriction, including without limitation the rights 10 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 copies of the Software, and to permit persons to whom the Software is 12 furnished to do so, subject to the following conditions: 13 14 The above copyright notice and this permission notice shall be included in 15 all copies or substantial portions of the Software. 16 17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23 THE SOFTWARE. 24 ****************************************************************************/ 25 26 /** 27 * The Slider control of Cocos UI. 28 * @class 29 * @extends ccui.Widget 30 * 31 * @property {Number} percent - The current progress of loadingbar 32 */ 33 ccui.Slider = ccui.Widget.extend(/** @lends ccui.Slider# */{ 34 _barRenderer: null, 35 _progressBarRenderer: null, 36 _barTextureSize: null, 37 _progressBarTextureSize: null, 38 _slidBallNormalRenderer: null, 39 _slidBallPressedRenderer: null, 40 _slidBallDisabledRenderer: null, 41 _slidBallRenderer: null, 42 _barLength: 0, 43 _percent: 0, 44 _scale9Enabled: false, 45 _prevIgnoreSize: true, 46 _textureFile: "", 47 _progressBarTextureFile: "", 48 _slidBallNormalTextureFile: "", 49 _slidBallPressedTextureFile: "", 50 _slidBallDisabledTextureFile: "", 51 _capInsetsBarRenderer: null, 52 _capInsetsProgressBarRenderer: null, 53 _sliderEventListener: null, 54 _sliderEventSelector: null, 55 _barTexType: ccui.Widget.LOCAL_TEXTURE, 56 _progressBarTexType: ccui.Widget.LOCAL_TEXTURE, 57 _ballNTexType: ccui.Widget.LOCAL_TEXTURE, 58 _ballPTexType: ccui.Widget.LOCAL_TEXTURE, 59 _ballDTexType: ccui.Widget.LOCAL_TEXTURE, 60 _isTextureLoaded: false, 61 _className: "Slider", 62 _barRendererAdaptDirty: true, 63 _progressBarRendererDirty: true, 64 _unifySize: false, 65 _zoomScale: 0.1, 66 67 _sliderBallNormalTextureScaleX: 1, 68 _sliderBallNormalTextureScaleY: 1, 69 70 /** 71 * allocates and initializes a UISlider. 72 * Constructor of ccui.Slider. override it to extend the construction behavior, remember to call "this._super()" in the extended "ctor" function. 73 * @example 74 * // example 75 * var uiSlider = new ccui.Slider(); 76 */ 77 ctor: function (barTextureName, normalBallTextureName, resType) { 78 this._barTextureSize = cc.size(0,0); 79 this._progressBarTextureSize = cc.size(0, 0); 80 this._capInsetsBarRenderer = cc.rect(0, 0, 0, 0); 81 this._capInsetsProgressBarRenderer = cc.rect(0, 0, 0, 0); 82 ccui.Widget.prototype.ctor.call(this); 83 84 resType = resType == null ? 0 : resType; 85 this.setTouchEnabled(true); 86 barTextureName && this.loadBarTexture(barTextureName, resType); 87 normalBallTextureName && this.loadSlidBallTextures(normalBallTextureName, resType); 88 }, 89 90 /** 91 * Initializes a ccui.Slider. Please do not call this function by yourself, you should pass the parameters to constructor to initialize it. 92 * @returns {boolean} 93 * @override 94 */ 95 init: function () { 96 return ccui.Widget.prototype.init.call(this); 97 }, 98 99 _initRenderer: function () { 100 //todo use Scale9Sprite 101 this._barRenderer = new cc.Sprite(); 102 this._progressBarRenderer = new cc.Sprite(); 103 this._progressBarRenderer.setAnchorPoint(0.0, 0.5); 104 this.addProtectedChild(this._barRenderer, ccui.Slider.BASEBAR_RENDERER_ZORDER, -1); 105 this.addProtectedChild(this._progressBarRenderer, ccui.Slider.PROGRESSBAR_RENDERER_ZORDER, -1); 106 this._slidBallNormalRenderer = new cc.Sprite(); 107 this._slidBallPressedRenderer = new cc.Sprite(); 108 this._slidBallPressedRenderer.setVisible(false); 109 this._slidBallDisabledRenderer = new cc.Sprite(); 110 this._slidBallDisabledRenderer.setVisible(false); 111 this._slidBallRenderer = new cc.Node(); 112 this._slidBallRenderer.addChild(this._slidBallNormalRenderer); 113 this._slidBallRenderer.addChild(this._slidBallPressedRenderer); 114 this._slidBallRenderer.addChild(this._slidBallDisabledRenderer); 115 this._slidBallRenderer.setCascadeColorEnabled(true); 116 this._slidBallRenderer.setCascadeOpacityEnabled(true); 117 118 this.addProtectedChild(this._slidBallRenderer, ccui.Slider.BALL_RENDERER_ZORDER, -1); 119 }, 120 121 /** 122 * Loads texture for slider bar. 123 * @param {String} fileName 124 * @param {ccui.Widget.LOCAL_TEXTURE|ccui.Widget.PLIST_TEXTURE} texType 125 */ 126 loadBarTexture: function (fileName, texType) { 127 if (!fileName) { 128 return; 129 } 130 texType = texType || ccui.Widget.LOCAL_TEXTURE; 131 this._textureFile = fileName; 132 this._barTexType = texType; 133 var barRenderer = this._barRenderer; 134 135 var self = this; 136 if(!barRenderer._textureLoaded){ 137 barRenderer.addEventListener("load", function(){ 138 self.loadBarTexture(self._textureFile, self._barTexType); 139 }); 140 } 141 142 switch (this._barTexType) { 143 case ccui.Widget.LOCAL_TEXTURE: 144 //SetTexture cannot load resource 145 barRenderer.initWithFile(fileName); 146 break; 147 case ccui.Widget.PLIST_TEXTURE: 148 //SetTexture cannot load resource 149 barRenderer.initWithSpriteFrameName(fileName); 150 break; 151 default: 152 break; 153 } 154 this._updateChildrenDisplayedRGBA(); 155 156 this._barRendererAdaptDirty = true; 157 this._progressBarRendererDirty = true; 158 this._updateContentSizeWithTextureSize(this._barRenderer.getContentSize()); 159 this._findLayout(); 160 this._barTextureSize = this._barRenderer.getContentSize(); 161 }, 162 163 /** 164 * Loads dark state texture for slider progress bar. 165 * @param {String} fileName 166 * @param {ccui.Widget.LOCAL_TEXTURE|ccui.Widget.PLIST_TEXTURE} texType 167 */ 168 loadProgressBarTexture: function (fileName, texType) { 169 if (!fileName) { 170 return; 171 } 172 texType = texType || ccui.Widget.LOCAL_TEXTURE; 173 this._progressBarTextureFile = fileName; 174 this._progressBarTexType = texType; 175 var progressBarRenderer = this._progressBarRenderer; 176 177 var self = this; 178 if(!progressBarRenderer._textureLoaded){ 179 progressBarRenderer.addEventListener("load", function(){ 180 self.loadProgressBarTexture(self._progressBarTextureFile, self._progressBarTexType); 181 }); 182 } 183 184 switch (this._progressBarTexType) { 185 case ccui.Widget.LOCAL_TEXTURE: 186 //SetTexture cannot load resource 187 progressBarRenderer.initWithFile(fileName); 188 break; 189 case ccui.Widget.PLIST_TEXTURE: 190 //SetTexture cannot load resource 191 progressBarRenderer.initWithSpriteFrameName(fileName); 192 break; 193 default: 194 break; 195 } 196 this._updateChildrenDisplayedRGBA(); 197 198 this._progressBarRenderer.setAnchorPoint(cc.p(0, 0.5)); 199 var tz = this._progressBarRenderer.getContentSize(); 200 this._progressBarTextureSize = {width: tz.width, height: tz.height}; 201 this._progressBarRendererDirty = true; 202 this._findLayout(); 203 }, 204 205 /** 206 * Sets if slider is using scale9 renderer. 207 * @param {Boolean} able 208 */ 209 setScale9Enabled: function (able) { 210 //todo use setScale9Enabled 211 if (this._scale9Enabled === able) 212 return; 213 214 this._scale9Enabled = able; 215 this.removeProtectedChild(this._barRenderer, true); 216 this.removeProtectedChild(this._progressBarRenderer, true); 217 this._barRenderer = null; 218 this._progressBarRenderer = null; 219 if (this._scale9Enabled) { 220 this._barRenderer = new ccui.Scale9Sprite(); 221 this._progressBarRenderer = new ccui.Scale9Sprite(); 222 } else { 223 this._barRenderer = new cc.Sprite(); 224 this._progressBarRenderer = new cc.Sprite(); 225 } 226 this.loadBarTexture(this._textureFile, this._barTexType); 227 this.loadProgressBarTexture(this._progressBarTextureFile, this._progressBarTexType); 228 this.addProtectedChild(this._barRenderer, ccui.Slider.BASEBAR_RENDERER_ZORDER, -1); 229 this.addProtectedChild(this._progressBarRenderer, ccui.Slider.PROGRESSBAR_RENDERER_ZORDER, -1); 230 if (this._scale9Enabled) { 231 var ignoreBefore = this._ignoreSize; 232 this.ignoreContentAdaptWithSize(false); 233 this._prevIgnoreSize = ignoreBefore; 234 } else { 235 this.ignoreContentAdaptWithSize(this._prevIgnoreSize); 236 } 237 this.setCapInsetsBarRenderer(this._capInsetsBarRenderer); 238 this.setCapInsetProgressBarRenderer(this._capInsetsProgressBarRenderer); 239 this._barRendererAdaptDirty = true; 240 this._progressBarRendererDirty = true; 241 }, 242 243 /** 244 * Returns slider is using scale9 renderer or not. 245 * @returns {Boolean} 246 */ 247 isScale9Enabled: function () { 248 return this._scale9Enabled; 249 }, 250 251 /** 252 * override "ignoreContentAdaptWithSize" method of widget. 253 * @param {Boolean} ignore 254 */ 255 ignoreContentAdaptWithSize: function (ignore) { 256 if (!this._scale9Enabled || (this._scale9Enabled && !ignore)) { 257 ccui.Widget.prototype.ignoreContentAdaptWithSize.call(this, ignore); 258 this._prevIgnoreSize = ignore; 259 } 260 }, 261 262 /** 263 * Sets capinsets for slider, if slider is using scale9 renderer. 264 * @param {cc.Rect} capInsets 265 */ 266 setCapInsets: function (capInsets) { 267 this.setCapInsetsBarRenderer(capInsets); 268 this.setCapInsetProgressBarRenderer(capInsets); 269 }, 270 271 /** 272 * Sets capinsets for slider's renderer, if slider is using scale9 renderer. 273 * @param {cc.Rect} capInsets 274 */ 275 setCapInsetsBarRenderer: function (capInsets) { 276 if(!capInsets) 277 return; 278 var locInsets = this._capInsetsBarRenderer; 279 locInsets.x = capInsets.x; 280 locInsets.y = capInsets.y; 281 locInsets.width = capInsets.width; 282 locInsets.height = capInsets.height; 283 if (!this._scale9Enabled) 284 return; 285 this._barRenderer.setCapInsets(capInsets); 286 }, 287 288 /** 289 * Returns cap insets for slider. 290 * @returns {cc.Rect} 291 */ 292 getCapInsetsBarRenderer: function () { 293 return cc.rect(this._capInsetsBarRenderer); 294 }, 295 296 /** 297 * Sets capinsets of ProgressBar for slider, if slider is using scale9 renderer. 298 * @param {cc.Rect} capInsets 299 */ 300 setCapInsetProgressBarRenderer: function (capInsets) { 301 if(!capInsets) 302 return; 303 var locInsets = this._capInsetsProgressBarRenderer; 304 locInsets.x = capInsets.x; 305 locInsets.y = capInsets.y; 306 locInsets.width = capInsets.width; 307 locInsets.height = capInsets.height; 308 if (!this._scale9Enabled) 309 return; 310 this._progressBarRenderer.setCapInsets(capInsets); 311 }, 312 313 /** 314 * Returns cap insets of ProgressBar for slider. 315 * @returns {cc.Rect} 316 */ 317 getCapInsetsProgressBarRenderer: function () { 318 return cc.rect(this._capInsetsProgressBarRenderer); 319 }, 320 321 /** 322 * Loads textures for slider ball. 323 * @param {String} normal 324 * @param {String} pressed 325 * @param {String} disabled 326 * @param {ccui.Widget.LOCAL_TEXTURE|ccui.Widget.PLIST_TEXTURE} texType 327 */ 328 loadSlidBallTextures: function (normal, pressed, disabled, texType) { 329 this.loadSlidBallTextureNormal(normal, texType); 330 this.loadSlidBallTexturePressed(pressed, texType); 331 this.loadSlidBallTextureDisabled(disabled, texType); 332 }, 333 334 /** 335 * Loads normal state texture for slider ball. 336 * @param {String} normal 337 * @param {ccui.Widget.LOCAL_TEXTURE|ccui.Widget.PLIST_TEXTURE} texType 338 */ 339 loadSlidBallTextureNormal: function (normal, texType) { 340 if (!normal) { 341 return; 342 } 343 texType = texType || ccui.Widget.LOCAL_TEXTURE; 344 this._slidBallNormalTextureFile = normal; 345 this._ballNTexType = texType; 346 347 var self = this; 348 if(!this._slidBallNormalRenderer._textureLoaded){ 349 this._slidBallNormalRenderer.addEventListener("load", function(){ 350 self.loadSlidBallTextureNormal(self._slidBallNormalTextureFile, self._ballNTexType); 351 }); 352 } 353 354 switch (this._ballNTexType) { 355 case ccui.Widget.LOCAL_TEXTURE: 356 //SetTexture cannot load resource 357 this._slidBallNormalRenderer.initWithFile(normal); 358 break; 359 case ccui.Widget.PLIST_TEXTURE: 360 //SetTexture cannot load resource 361 this._slidBallNormalRenderer.initWithSpriteFrameName(normal); 362 break; 363 default: 364 break; 365 } 366 this._updateChildrenDisplayedRGBA(); 367 this._findLayout(); 368 }, 369 370 /** 371 * Loads selected state texture for slider ball. 372 * @param {String} pressed 373 * @param {ccui.Widget.LOCAL_TEXTURE|ccui.Widget.PLIST_TEXTURE} texType 374 */ 375 loadSlidBallTexturePressed: function (pressed, texType) { 376 if (!pressed) { 377 return; 378 } 379 texType = texType || ccui.Widget.LOCAL_TEXTURE; 380 this._slidBallPressedTextureFile = pressed; 381 this._ballPTexType = texType; 382 383 var self = this; 384 if(!this._slidBallPressedRenderer._textureLoaded){ 385 this._slidBallPressedRenderer.addEventListener("load", function(){ 386 self.loadSlidBallTexturePressed(self._slidBallPressedTextureFile, self._ballPTexType); 387 }); 388 } 389 390 switch (this._ballPTexType) { 391 case ccui.Widget.LOCAL_TEXTURE: 392 //SetTexture cannot load resource 393 this._slidBallPressedRenderer.initWithFile(pressed); 394 break; 395 case ccui.Widget.PLIST_TEXTURE: 396 //SetTexture cannot load resource 397 this._slidBallPressedRenderer.initWithSpriteFrameName(pressed); 398 break; 399 default: 400 break; 401 } 402 this._updateChildrenDisplayedRGBA(); 403 this._findLayout(); 404 }, 405 406 /** 407 * Load dark state texture for slider ball. 408 * @param {String} disabled 409 * @param {ccui.Widget.LOCAL_TEXTURE|ccui.Widget.PLIST_TEXTURE} texType 410 */ 411 loadSlidBallTextureDisabled: function (disabled, texType) { 412 if (!disabled) { 413 return; 414 } 415 texType = texType || ccui.Widget.LOCAL_TEXTURE; 416 this._slidBallDisabledTextureFile = disabled; 417 this._ballDTexType = texType; 418 419 var self = this; 420 if(!this._slidBallDisabledRenderer._textureLoaded){ 421 this._slidBallDisabledRenderer.addEventListener("load", function(){ 422 self.loadSlidBallTextureDisabled(self._slidBallDisabledTextureFile, self._ballDTexType); 423 }); 424 } 425 426 switch (this._ballDTexType) { 427 case ccui.Widget.LOCAL_TEXTURE: 428 //SetTexture cannot load resource 429 this._slidBallDisabledRenderer.initWithFile(disabled); 430 break; 431 case ccui.Widget.PLIST_TEXTURE: 432 //SetTexture cannot load resource 433 this._slidBallDisabledRenderer.initWithSpriteFrameName(disabled); 434 break; 435 default: 436 break; 437 } 438 this._updateChildrenDisplayedRGBA(); 439 this._findLayout(); 440 }, 441 442 /** 443 * Changes the progress direction of slider. 444 * @param {number} percent 445 */ 446 setPercent: function (percent) { 447 if (percent > 100) 448 percent = 100; 449 if (percent < 0) 450 percent = 0; 451 this._percent = percent; 452 var res = percent / 100.0; 453 var dis = this._barLength * res; 454 this._slidBallRenderer.setPosition(dis, this._contentSize.height / 2); 455 if (this._scale9Enabled) 456 this._progressBarRenderer.setPreferredSize(cc.size(dis, this._contentSize.height)); 457 else { 458 var spriteRenderer = this._progressBarRenderer; 459 var rect = spriteRenderer.getTextureRect(); 460 spriteRenderer.setTextureRect( 461 cc.rect(rect.x, rect.y, dis / spriteRenderer._scaleX, rect.height), 462 spriteRenderer.isTextureRectRotated() 463 ); 464 } 465 }, 466 467 /** 468 * test the point whether location in loadingBar's bounding box. 469 * @override 470 * @param {cc.Point} pt 471 * @returns {boolean} 472 */ 473 hitTest: function(pt){ 474 var nsp = this._slidBallNormalRenderer.convertToNodeSpace(pt); 475 var ballSize = this._slidBallNormalRenderer.getContentSize(); 476 var ballRect = cc.rect(0,0, ballSize.width, ballSize.height); 477 // if (ballRect.containsPoint(nsp)) { 478 return (nsp.x >= ballRect.x && 479 nsp.x <= (ballRect.x + ballRect.width) && 480 nsp.y >= ballRect.y && 481 nsp.y <= (ballRect.y +ballRect.height)); 482 }, 483 484 onTouchBegan: function (touch, event) { 485 var pass = ccui.Widget.prototype.onTouchBegan.call(this, touch, event); 486 if (this._hit) { 487 var nsp = this.convertToNodeSpace(this._touchBeganPosition); 488 this.setPercent(this._getPercentWithBallPos(nsp.x)); 489 this._percentChangedEvent(); 490 } 491 return pass; 492 }, 493 494 onTouchMoved: function (touch, event) { 495 var touchPoint = touch.getLocation(); 496 var nsp = this.convertToNodeSpace(touchPoint); 497 this.setPercent(this._getPercentWithBallPos(nsp.x)); 498 this._percentChangedEvent(); 499 }, 500 501 onTouchEnded: function (touch, event) { 502 ccui.Widget.prototype.onTouchEnded.call(this, touch, event); 503 }, 504 505 onTouchCancelled: function (touch, event) { 506 ccui.Widget.prototype.onTouchCancelled.call(this, touch, event); 507 }, 508 509 /** 510 * Returns percent with ball's position. 511 * @param {cc.Point} px 512 * @returns {number} 513 */ 514 _getPercentWithBallPos: function (px) { 515 return ((px/this._barLength)*100); 516 }, 517 518 /** 519 * add event listener 520 * @param {Function} selector 521 * @param {Object} [target=] 522 * @deprecated since v3.0, please use addEventListener instead. 523 */ 524 addEventListenerSlider: function (selector, target) { 525 this.addEventListener(selector, target); 526 }, 527 528 /** 529 * Adds a callback 530 * @param {Function} selector 531 * @param {Object} [target=] 532 */ 533 addEventListener: function(selector, target){ 534 this._sliderEventSelector = selector; //when target is undefined, _sliderEventSelector = _eventCallback 535 this._sliderEventListener = target; 536 }, 537 538 _percentChangedEvent: function () { 539 if(this._sliderEventSelector){ 540 if (this._sliderEventListener) 541 this._sliderEventSelector.call(this._sliderEventListener, this, ccui.Slider.EVENT_PERCENT_CHANGED); 542 else 543 this._sliderEventSelector(this, ccui.Slider.EVENT_PERCENT_CHANGED); // _eventCallback 544 } 545 if (this._ccEventCallback) 546 this._ccEventCallback(this, ccui.Slider.EVENT_PERCENT_CHANGED); 547 }, 548 549 /** 550 * Gets the progress direction of slider. 551 * @returns {number} 552 */ 553 getPercent: function () { 554 return this._percent; 555 }, 556 557 _onSizeChanged: function () { 558 ccui.Widget.prototype._onSizeChanged.call(this); 559 this._barRendererAdaptDirty = true; 560 this._progressBarRendererDirty = true; 561 }, 562 563 _adaptRenderers: function(){ 564 if (this._barRendererAdaptDirty) 565 { 566 this._barRendererScaleChangedWithSize(); 567 this._barRendererAdaptDirty = false; 568 } 569 if (this._progressBarRendererDirty) 570 { 571 this._progressBarRendererScaleChangedWithSize(); 572 this._progressBarRendererDirty = false; 573 } 574 }, 575 576 /** 577 * Returns the content size of bar renderer. 578 * @returns {cc.Size} 579 */ 580 getVirtualRendererSize: function(){ 581 return this._barRenderer.getContentSize(); 582 }, 583 584 /** 585 * Returns the bar renderer. 586 * @returns {cc.Node} 587 */ 588 getVirtualRenderer: function () { 589 return this._barRenderer; 590 }, 591 592 _barRendererScaleChangedWithSize: function () { 593 if (this._unifySize){ 594 this._barLength = this._contentSize.width; 595 this._barRenderer.setPreferredSize(this._contentSize); 596 }else if(this._ignoreSize) { 597 this._barRenderer.setScale(1.0); 598 this._barLength = this._contentSize.width; 599 }else { 600 this._barLength = this._contentSize.width; 601 if (this._scale9Enabled) { 602 this._barRenderer.setPreferredSize(this._contentSize); 603 this._barRenderer.setScale(1.0); 604 } else { 605 var btextureSize = this._barTextureSize; 606 if (btextureSize.width <= 0.0 || btextureSize.height <= 0.0) { 607 this._barRenderer.setScale(1.0); 608 }else{ 609 var bscaleX = this._contentSize.width / btextureSize.width; 610 var bscaleY = this._contentSize.height / btextureSize.height; 611 this._barRenderer.setScaleX(bscaleX); 612 this._barRenderer.setScaleY(bscaleY); 613 } 614 } 615 } 616 this._barRenderer.setPosition(this._contentSize.width / 2.0, this._contentSize.height / 2.0); 617 this.setPercent(this._percent); 618 }, 619 620 _progressBarRendererScaleChangedWithSize: function () { 621 if(this._unifySize){ 622 this._progressBarRenderer.setPreferredSize(this._contentSize); 623 }else if(this._ignoreSize) { 624 if (!this._scale9Enabled) { 625 var ptextureSize = this._progressBarTextureSize; 626 var pscaleX = this._contentSize.width / ptextureSize.width; 627 var pscaleY = this._contentSize.height / ptextureSize.height; 628 this._progressBarRenderer.setScaleX(pscaleX); 629 this._progressBarRenderer.setScaleY(pscaleY); 630 } 631 } 632 else { 633 if (this._scale9Enabled) { 634 this._progressBarRenderer.setPreferredSize(this._contentSize); 635 this._progressBarRenderer.setScale(1); 636 } 637 else { 638 var ptextureSize = this._progressBarTextureSize; 639 if (ptextureSize.width <= 0.0 || ptextureSize.height <= 0.0) { 640 this._progressBarRenderer.setScale(1.0); 641 return; 642 } 643 var pscaleX = this._contentSize.width / ptextureSize.width; 644 var pscaleY = this._contentSize.height / ptextureSize.height; 645 this._progressBarRenderer.setScaleX(pscaleX); 646 this._progressBarRenderer.setScaleY(pscaleY); 647 } 648 } 649 this._progressBarRenderer.setPosition(0.0, this._contentSize.height / 2.0); 650 this.setPercent(this._percent); 651 }, 652 653 _onPressStateChangedToNormal: function () { 654 this._slidBallNormalRenderer.setVisible(true); 655 this._slidBallPressedRenderer.setVisible(false); 656 this._slidBallDisabledRenderer.setVisible(false); 657 658 this._slidBallNormalRenderer.setScale(this._sliderBallNormalTextureScaleX, this._sliderBallNormalTextureScaleY); 659 }, 660 661 _onPressStateChangedToPressed: function () { 662 if (!this._slidBallPressedTextureFile){ 663 this._slidBallNormalRenderer.setScale(this._sliderBallNormalTextureScaleX + this._zoomScale, this._sliderBallNormalTextureScaleY + this._zoomScale); 664 }else{ 665 this._slidBallNormalRenderer.setVisible(false); 666 this._slidBallPressedRenderer.setVisible(true); 667 this._slidBallDisabledRenderer.setVisible(false); 668 } 669 }, 670 671 _onPressStateChangedToDisabled: function () { 672 if (this._slidBallDisabledTextureFile){ 673 this._slidBallNormalRenderer.setVisible(false); 674 this._slidBallDisabledRenderer.setVisible(true); 675 } 676 this._slidBallNormalRenderer.setScale(this._sliderBallNormalTextureScaleX, this._sliderBallNormalTextureScaleY); 677 this._slidBallPressedRenderer.setVisible(false); 678 }, 679 680 setZoomScale: function(scale){ 681 this._zoomScale = scale; 682 }, 683 684 getZoomScale: function(){ 685 return this._zoomScale; 686 }, 687 688 /** 689 * Returns the "class name" of ccui.LoadingBar. 690 * @returns {string} 691 */ 692 getDescription: function () { 693 return "Slider"; 694 }, 695 696 _createCloneInstance: function () { 697 return new ccui.Slider(); 698 }, 699 700 _copySpecialProperties: function (slider) { 701 this._prevIgnoreSize = slider._prevIgnoreSize; 702 this.setScale9Enabled(slider._scale9Enabled); 703 this.loadBarTexture(slider._textureFile, slider._barTexType); 704 this.loadProgressBarTexture(slider._progressBarTextureFile, slider._progressBarTexType); 705 this.loadSlidBallTextureNormal(slider._slidBallNormalTextureFile, slider._ballNTexType); 706 this.loadSlidBallTexturePressed(slider._slidBallPressedTextureFile, slider._ballPTexType); 707 this.loadSlidBallTextureDisabled(slider._slidBallDisabledTextureFile, slider._ballDTexType); 708 this.setPercent(slider.getPercent()); 709 this._sliderEventListener = slider._sliderEventListener; 710 this._sliderEventSelector = slider._sliderEventSelector; 711 this._zoomScale = slider._zoomScale; 712 this._ccEventCallback = slider._ccEventCallback; 713 714 } 715 }); 716 717 var _p = ccui.Slider.prototype; 718 719 // Extended properties 720 /** @expose */ 721 _p.percent; 722 cc.defineGetterSetter(_p, "percent", _p.getPercent, _p.setPercent); 723 724 _p = null; 725 726 /** 727 * allocates and initializes a UISlider. 728 * @deprecated since v3.0, please use new ccui.Slider() instead. 729 * @return {ccui.Slider} 730 */ 731 ccui.Slider.create = function (barTextureName, normalBallTextureName, resType) { 732 return new ccui.Slider(barTextureName, normalBallTextureName, resType); 733 }; 734 735 // Constant 736 //Slider event type 737 /** 738 * The percent change event flag of ccui.Slider. 739 * @constant 740 * @type {number} 741 */ 742 ccui.Slider.EVENT_PERCENT_CHANGED = 0; 743 744 //Render zorder 745 /** 746 * The zOrder value of ccui.Slider's base bar renderer. 747 * @constant 748 * @type {number} 749 */ 750 ccui.Slider.BASEBAR_RENDERER_ZORDER = -3; 751 /** 752 * The zOrder value of ccui.Slider's progress bar renderer. 753 * @constant 754 * @type {number} 755 */ 756 ccui.Slider.PROGRESSBAR_RENDERER_ZORDER = -2; 757 /** 758 * The zOrder value of ccui.Slider's ball renderer. 759 * @constant 760 * @type {number} 761 */ 762 ccui.Slider.BALL_RENDERER_ZORDER = -1;