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;