Build 2 rows in a one row carussel

Report · Jul 06, 2015

Hello Community,

i need a serious help in a script and have as a "Beginner" absolutly no clue how to do or where to do it.

To the Action:

There is a script in Flash Action Script what should show an container where are should be some Pictures inside.

This is the Bar at the Bottom:

Here i need now 2 rows of that Bar but the two arrows at the left and right should be in the high of both rows - so if you click the left arrow, the 6 pictures of the bar-line 1 (see above, there comes 6 pictures in) and the 6 pictures of the new bar line 2 (should be above) should scroll at the same time to the right, or left if clicked the right arrow.

What must i change or include to get this.

Must i start a new script ? If yes what i must write in that it works as i need it ?

It would be very very very great if you can give me the needed script add-on here

kind regard

The scrip so far:

[spoiler][code]

package lesta.controls

{

import scaleform.clik.controls.CoreList;

import scaleform.clik.controls.Button;

import flash.display.MovieClip;

import flash.geom.Point;

import scaleform.clik.core.UIComponent;

import scaleform.clik.events.ButtonEvent;

import flash.events.Event;

import scaleform.clik.events.InputEvent;

import flash.events.MouseEvent;

import scaleform.clik.interfaces.IDataProvider;

import scaleform.clik.interfaces.IListItemRenderer;

import scaleform.clik.events.ListEvent;

import scaleform.gfx.MouseEventEx;

import scaleform.clik.constants.InvalidationType;

import lesta.cpp.Tween;

import flash.display.DisplayObject;

import scaleform.clik.data.ListData;

import flash.utils.setInterval;

import flash.utils.clearInterval;

import scaleform.clik.ui.InputDetails;

import scaleform.clik.constants.InputValue;

import scaleform.clik.constants.NavigationCode;

public class Carousel extends CoreList

{

public static const INVALIDATE_SCROLL_POSITION:String = "invalidateScrollPosition";

public static const DIRECTION_LEFT:int = -1;

public static const DIRECTION_RIGHT:int = 1;

public static const DIRECTION_STOP:int = 0;

private var ARROW_DURATION:Number = 500;

private var DRAG_INTERVAL:Number = 40.0;

private var ARROW_INTERVAL:Number = 150.0;

public var mButtonLeftArrow:Button;

public var mButtonRightArrow:Button;

public var mRenderersMask:MovieClip;

private var mItemsHorPadding:Number = 0;

private var mItemsHorSpace:Number = 0;

private var mIsFillEmpty:Boolean = false;

private var mItemsCountAdjust:int = -1;

private var mSpeedCheck:Array;

private var mDisableScaleItems:Boolean = false;

private var mInitButtonsScale:Point;

private var mInitMaskRightMargin:Number = 0;

private var mInitMaskLeftMargin:Number = 0;

private var mCountItems:int = 0;

private var mScrollPosition:Number = 0;

private var mItemScrollPosition:uint = 0;

private var mColumnWidth:Number = 1;

private var currentTweenId:int = -1;

private var mIdDraggingInterval:int = -1;

private var mIdArrowInterval:int = -1;

private var mIdKeyArrowInterval:int = -1;

private var mMouseDownPosition:Point;

private var mListDragSpeeds:Array;

private var mArrowDirection:int = 0;

private var mContainerPositionBeforeDrag:Number = 0;

private var mLastPressItem:UIComponent = null;

private var mKeyArrowDirection:int = 0;

public function Carousel()

{

this.mSpeedCheck = [0.5,1.5,3];

this.mInitButtonsScale = new Point();

this.mMouseDownPosition = new Point();

this.mListDragSpeeds = [];

super();

this.mInitButtonsScale.x = this.mButtonLeftArrow.scaleX;

this.mInitButtonsScale.y = this.mButtonLeftArrow.scaleY;

this.mInitMaskLeftMargin = this.mRenderersMask.x;

this.mInitMaskRightMargin = width / scaleX - this.mRenderersMask.x - this.mRenderersMask.width;

scaleX = 1;

scaleY = 1;

}

override protected function configUI() : void

{

super.configUI();

this.mButtonLeftArrow.addEventListener(ButtonEvent.PRESS,this.onButtonLeftArrowPress,false,0,true);

this.mButtonLeftArrow.addEventListener(ButtonEvent.CLICK,this.onButtonLeftArrowClick,false,0,true);

this.mButtonLeftArrow.addEventListener(ButtonEvent.RELEASE_OUTSIDE,this.onButtonLeftArrowReleaseOutside,false,0,true);

this.mButtonRightArrow.addEventListener(ButtonEvent.PRESS,this.onButtonRightArrowPress,false,0,true);

this.mButtonRightArrow.addEventListener(ButtonEvent.CLICK,this.onButtonRightArrowClick,false,0,true);

this.mButtonRightArrow.addEventListener(ButtonEvent.RELEASE_OUTSIDE,this.onButtonRightArrowReleaseOutside,false,0,true);

container.mask = this.mRenderersMask;

}

override protected function addedToStage(param1:Event) : void

{

super.addedToStage(param1);

stage.addEventListener(InputEvent.INPUT,this.handleInput,false,0,true);

stage.addEventListener(MouseEvent.MOUSE_UP,this.handleMouseUpOnStage,false,0,true);

}

override public function set width(param1:Number) : void

{

this.mItemsCountAdjust = -1;

super.width = param1;

}

public function set fillEmpty(param1:Boolean) : void

{

this.mIsFillEmpty = param1;

invalidateData();

}

override public function set dataProvider(param1:IDataProvider) : void

{

super.dataProvider = param1;

this.mCountItems = super.dataProvider.length;

invalidateRenderers();

invalidateData();

}

override public function set itemRendererName(param1:String) : void

{

super.itemRendererName = param1;

this.recalcColumnWidth();

invalidateRenderers();

invalidateSize();

}

public function set itemsHorSpace(param1:Number) : void

{

this.mItemsHorSpace = param1;

}

public function set itemPaddingHorz(param1:Number) : void

{

this.mItemsHorPadding = param1;

this.recalcColumnWidth();

invalidateSize();

}

public function set disableScaleItems(param1:Boolean) : void

{

this.mDisableScaleItems = param1;

invalidateSize();

}

public function adjustToItemCount(param1:int) : void

{

if(param1 == -1)

{

this.mItemsCountAdjust = -1;

return;

}

this.mItemsCountAdjust = param1;

super.width = this.getAdjustedWidthToCount(param1);

invalidateSize();

this.mItemScrollPosition = 0;

this.scrollPosition = 0;

}

public function set scrollPosition(param1:Number) : void

{

if(param1 < 0)

{

var param1:Number = 0;

}

if(param1 > 1)

{

param1 = 1;

}

this.mScrollPosition = param1;

invalidate(INVALIDATE_SCROLL_POSITION);

}

override public function scrollToIndex(param1:uint) : void

{

if(this.mCountItems > this.countVisibleItems)

{

if(param1 > this.countRenderers - this.countVisibleItems)

{

var param1:uint = this.countRenderers - this.countVisibleItems;

}

else

{

param1 = 0;

}

this.mItemScrollPosition = param1;

this.scrollPosition = this.getPartByIndex(param1);

}

public function getAdjustedWidthToCount(param1:int) : Number

{

return param1 * (this.mColumnWidth - this.mItemsHorPadding * 2) + (param1 - 1) * this.mItemsHorSpace + this.mInitMaskLeftMargin + this.mInitMaskRightMargin;

}

public function get countVisibleItems() : int

{

if(this.mColumnWidth == 0)

{

return 0;

}

var _loc1_:int = Math.ceil((width - this.mInitMaskLeftMargin - this.mInitMaskRightMargin) / this.mColumnWidth);

return this.mItemsCountAdjust != -1?this.mItemsCountAdjust:_loc1_;

}

override public function get availableWidth() : Number

{

return this.mRenderersMask.width * scaleX;

}

override public function get availableHeight() : Number

{

return this.mRenderersMask.height * scaleY;

}

public function get scrollPosition() : Number

{

return this.mScrollPosition;

}

override public function getRendererAt(param1:uint, param2:int = 0) : IListItemRenderer

{

if(_renderers == null)

{

return null;

}

if(_renderers.length <= param1)

{

return null;

}

return _renderers[param1];

}

override protected function setupRenderer(param1:IListItemRenderer) : void

{

param1.owner = this;

param1.focusTarget = this;

param1.tabEnabled = false;

param1.doubleClickEnabled = true;

param1.addEventListener(ButtonEvent.PRESS,this.handleItemPress,false,0,true);

param1.addEventListener(ButtonEvent.CLICK,this.handleItemClick,false,0,true);

param1.addEventListener(MouseEvent.DOUBLE_CLICK,this.dispatchItemEvent,false,0,true);

param1.addEventListener(MouseEvent.ROLL_OVER,this.dispatchItemEvent,false,0,true);

param1.addEventListener(MouseEvent.ROLL_OUT,this.dispatchItemEvent,false,0,true);

if(_usingExternalRenderers)

{

param1.addEventListener(MouseEvent.MOUSE_WHEEL,handleMouseWheel,false,0,true);

}

override protected function cleanUpRenderer(param1:IListItemRenderer) : void

{

param1.owner = null;

param1.focusTarget = null;

param1.doubleClickEnabled = false;

param1.removeEventListener(ButtonEvent.PRESS,this.handleItemPress);

param1.removeEventListener(ButtonEvent.CLICK,this.handleItemClick);

param1.removeEventListener(MouseEvent.DOUBLE_CLICK,this.dispatchItemEvent);

param1.removeEventListener(MouseEvent.ROLL_OVER,this.dispatchItemEvent);

param1.removeEventListener(MouseEvent.ROLL_OUT,this.dispatchItemEvent);

param1.removeEventListener(MouseEvent.MOUSE_WHEEL,handleMouseWheel);

}

override protected function dispatchItemEvent(param1:Event) : Boolean

{

var _loc2_:String = null;

switch(param1.type)

{

case ButtonEvent.PRESS:

_loc2_ = ListEvent.ITEM_PRESS;

break;

case ButtonEvent.CLICK:

_loc2_ = ListEvent.ITEM_CLICK;

break;

case ButtonEvent.RELEASE_OUTSIDE:

_loc2_ = "itemReleaseOutside";

break;

case MouseEvent.ROLL_OVER:

_loc2_ = ListEvent.ITEM_ROLL_OVER;

break;

case MouseEvent.ROLL_OUT:

_loc2_ = ListEvent.ITEM_ROLL_OUT;

break;

case MouseEvent.DOUBLE_CLICK:

_loc2_ = ListEvent.ITEM_DOUBLE_CLICK;

break;

default:

return true;

}

var _loc3_:IListItemRenderer = param1.currentTarget as IListItemRenderer;

var _loc4_:uint = 0;

if(param1 is ButtonEvent)

{

_loc4_ = (param1 as ButtonEvent).controllerIdx;

}

else if(param1 is MouseEventEx)

{

_loc4_ = (param1 as MouseEventEx).mouseIdx;

}

var _loc5_:uint = 0;

if(param1 is ButtonEvent)

{

_loc5_ = (param1 as ButtonEvent).buttonIdx;

}

else if(param1 is MouseEventEx)

{

_loc5_ = (param1 as MouseEventEx).buttonIdx;

}

var _loc6_:* = false;

if(param1 is ButtonEvent)

{

_loc6_ = (param1 as ButtonEvent).isKeyboard;

}

var _loc7_:ListEvent = new ListEvent(_loc2_,false,true,_loc3_.index,0,_loc3_.index,_loc3_,dataProvider[_loc3_.index],_loc4_,_loc5_,_loc6_);

return dispatchEvent(_loc7_);

}

override protected function draw() : void

{

var _loc1_:* = NaN;

var _loc2_:* = false;

var _loc3_:* = false;

super.draw();

if(isInvalid(InvalidationType.SIZE))

{

this.mRenderersMask.x = this.mInitMaskLeftMargin / scaleX;

this.mRenderersMask.width = (width - this.mInitMaskLeftMargin - this.mInitMaskRightMargin) / scaleX;

this.mButtonRightArrow.scaleX = this.mInitButtonsScale.x / this.scaleX;

this.mButtonRightArrow.scaleY = this.mInitButtonsScale.y / this.scaleY;

this.mButtonLeftArrow.scaleX = this.mInitButtonsScale.x / this.scaleX;

this.mButtonLeftArrow.scaleY = this.mInitButtonsScale.y / this.scaleY;

this.mButtonRightArrow.x = width / scaleX - this.mButtonRightArrow.width;

container.x = Math.round(this.getXByPart(0));

}

if(isInvalid(INVALIDATE_SCROLL_POSITION))

{

_loc1_ = this.ARROW_DURATION;

this.currentTweenId = Tween.to(container,0.5,{"x":container.x},{"x":this.getXByPart(this.mScrollPosition)},null,Tween.EASE_OUT_QUAD);

_loc2_ = this.mCountItems > this.countVisibleItems && this.mScrollPosition > this.getPartByIndex(0.5);

_loc3_ = this.mCountItems > this.countVisibleItems && this.mScrollPosition < this.getPartByIndex(this.mCountItems - this.countVisibleItems - 0.5);

if(this.mButtonLeftArrow.enabled != _loc2_)

{

this.mButtonLeftArrow.enabled = _loc2_;

if(!_loc2_)

{

this.stopArrowInterval(-1);

}

if(this.mButtonRightArrow.enabled != _loc3_)

{

this.mButtonRightArrow.enabled = _loc3_;

if(!_loc3_)

{

this.stopArrowInterval(1);

}

if(isInvalid(InvalidationType.DATA))

{

this.drawLayout();

this.drawRenderers(_totalRenderers);

}

container.mask = this.mRenderersMask;

}

override protected function drawLayout() : void

{

var _loc1_:uint = 0;

var _loc2_:* = NaN;

var _loc3_:* = NaN;

var _loc4_:* = NaN;

var _loc5_:* = false;

var _loc6_:uint = 0;

var _loc7_:IListItemRenderer = null;

if(_renderers != null)

{

_loc1_ = _renderers.length;

_loc2_ = this.availableHeight;

_loc3_ = -this.mItemsHorPadding;

_loc4_ = 0;

_loc5_ = isInvalid(InvalidationType.DATA);

_loc6_ = 0;

while(_loc6_ < _loc1_)

{

_loc7_ = this.getRendererAt(_loc6_);

_loc7_.x = Math.round(_loc3_);

_loc7_.y = Math.round(_loc4_);

if(!this.mDisableScaleItems)

{

_loc7_.height = _loc2_;

(_loc7_ as DisplayObject).scaleX = (_loc7_ as DisplayObject).scaleY;

}

if(!_loc5_)

{

_loc7_.validateNow();

}

_loc3_ = _loc3_ + (_loc7_.width - 2 * this.mItemsHorPadding + this.mItemsHorSpace);

_loc6_++;

}

override protected function updateSelectedIndex() : void

{

super.updateSelectedIndex();

this.refreshData();

}

override protected function refreshData() : void

{

this.drawLayout();

this.drawRenderers(_totalRenderers);

_dataProvider.requestItemRange(0,_dataProvider.length,this.populateData);

}

override protected function calculateRendererTotal(param1:Number, param2:Number) : uint

{

return _dataProvider.length;

}

override protected function drawRenderers(param1:Number) : void

{

var _loc2_:* = 0;

var _loc3_:* = 0;

var _loc4_:* = 0;

var _loc5_:IListItemRenderer = null;

var _loc6_:DisplayObject = null;

if(_renderers != null)

{

if(_itemRenderer == null)

{

trace("Renderer class not defined.");

return;

}

_loc2_ = !this.mIsFillEmpty?this.mCountItems:Math.max(this.mCountItems,this.countVisibleItems);

_loc3_ = _renderers.length;

while(_loc3_ < _loc2_)

{

_loc5_ = createRenderer(_loc3_);

if(_loc5_ == null)

{

break;

}

_renderers.push(_loc5_);

container.addChild(_loc5_ as DisplayObject);

_loc3_++;

}

_loc4_ = _renderers.length;

_loc3_ = _loc4_ - 1;

while(_loc3_ >= _loc2_)

{

_loc5_ = this.getRendererAt(_loc3_);

if(_loc5_ != null)

{

this.cleanUpRenderer(_loc5_);

_loc6_ = _loc5_ as DisplayObject;

if(container.contains(_loc6_))

{

container.removeChild(_loc6_);

}

_renderers.splice(_loc3_,1);

_loc3_--;

}

override protected function scrollList(param1:int) : void

{

super.scrollList(param1);

if(this.mItemScrollPosition - param1 >= 0)

{

this.scrollToIndex(this.mItemScrollPosition - param1);

}

else

{

this.scrollToIndex(0);

}

override protected function handleDataChange(param1:Event) : void

{

super.handleDataChange(param1);

this.mCountItems = super.dataProvider.length;

invalidateRenderers();

invalidateData();

}

protected function populateData(param1:Array) : void

{

var _loc5_:IListItemRenderer = null;

var _loc6_:uint = 0;

var _loc7_:ListData = null;

if(_renderers == null)

{

return;

}

var _loc2_:uint = param1.length;

var _loc3_:uint = _renderers.length;

var _loc4_:uint = 0;

while(_loc4_ < _loc3_)

{

_loc5_ = this.getRendererAt(_loc4_);

_loc6_ = _loc4_;

_loc7_ = new ListData(_loc6_,itemToLabel(param1[_loc4_]),_selectedIndex == _loc6_);

_loc5_.enabled = _loc4_ >= _loc2_?false:true;

_loc5_.selected = _selectedIndex == _loc6_;

_loc5_.setListData(_loc7_);

_loc5_.setData(_loc4_ < this.mCountItems?param1[_loc4_]:null);

_loc5_.validateNow();

_loc4_++;

}

protected function get countRenderers() : int

{

if(_renderers == null)

{

return 0;

}

return _renderers.length;

}

protected function recalcColumnWidth() : void

{

if(itemRenderer == null)

{

return;

}

var _loc1_:IListItemRenderer = createRenderer(0);

if(!this.mDisableScaleItems)

{

_loc1_.height = this.availableHeight;

(_loc1_ as DisplayObject).scaleX = (_loc1_ as DisplayObject).scaleY;

}

this.mColumnWidth = _loc1_.width;

this.cleanUpRenderer(_loc1_);

}

protected function getXByPart(param1:Number) : Number

{

var _loc2_:Number = container.width - this.availableWidth / scaleX - this.mItemsHorPadding * 2 / scaleX;

if(_loc2_ < 0)

{

_loc2_ = 0;

}

return this.mRenderersMask.x - _loc2_ * this.scrollPosition;

}

protected function getPartByX(param1:Number) : Number

{

var _loc2_:Number = container.width - this.availableWidth / scaleX - this.mItemsHorPadding * 2 / scaleX;

if(_loc2_ <= 0)

{

return 0;

}

return param1 = (this.mRenderersMask.x - param1) / _loc2_;

}

protected function getPartByIndex(param1:Number) : Number

{

if(this.mCountItems <= this.countVisibleItems)

{

return 0;

}

return 1 / (this.mCountItems - this.countVisibleItems) * param1;

}

private function climbScrollItemPosition(param1:int) : Number

{

if(this.mCountItems > this.countVisibleItems)

{

if(param1 > this.countRenderers - this.countVisibleItems)

{

var param1:int = this.countRenderers - this.countVisibleItems;

}

else

{

param1 = 0;

}

return param1;

}

private function climbDragPosition(param1:Number) : Number

{

var _loc2_:Number = container.width - this.availableWidth / scaleX - this.mItemsHorPadding * 2 / scaleX;

if(_loc2_ < 0)

{

_loc2_ = 0;

}

var _loc3_:Number = this.mRenderersMask.x + this.mColumnWidth / 2 / scaleX;

var _loc4_:Number = this.mRenderersMask.x - _loc2_ - this.mColumnWidth / 2 / scaleX;

var _loc5_:Number = param1;

_loc5_ = _loc5_ > _loc3_?_loc3_:_loc5_ < _loc4_?_loc4_:_loc5_;

return _loc5_;

}

protected function getScrollPositionForItem(param1:int) : Number

{

return param1 * this.mColumnWidth + (param1 - 1) * this.mItemsHorSpace + this.mInitMaskLeftMargin + this.mInitMaskRightMargin;

}

protected function stopTween() : void

{

Tween.kill(this.currentTweenId);

}

protected function getAverageLastSpeedDrag() : Number

{

var _loc2_:* = 0;

var _loc1_:Number = 0;

if(this.mListDragSpeeds.length > 0)

{

_loc2_ = 0;

while(_loc2_ < this.mListDragSpeeds.length)

{

_loc1_ = _loc1_ + this.mListDragSpeeds[_loc2_];

_loc2_++;

}

_loc1_ = _loc1_ / this.mListDragSpeeds.length;

}

return _loc1_;

}

private function onButtonRightArrowPress(param1:ButtonEvent) : void

{

this.mArrowDirection = 1;

this.scrollToIndex(this.mItemScrollPosition + 1);

if(this.mIdArrowInterval == -1)

{

this.mIdArrowInterval = setInterval(this.onArrowInterval,this.ARROW_INTERVAL);

}

private function onButtonRightArrowClick(param1:ButtonEvent) : void

{

this.stopArrowInterval(1);

}

private function onButtonRightArrowReleaseOutside(param1:ButtonEvent) : void

{

this.stopArrowInterval(1);

}

private function onButtonLeftArrowPress(param1:ButtonEvent) : void

{

this.mArrowDirection = -1;

if(this.mItemScrollPosition > 0)

{

this.scrollToIndex(this.mItemScrollPosition - 1);

}

if(this.mIdArrowInterval == -1)

{

this.mIdArrowInterval = setInterval(this.onArrowInterval,this.ARROW_INTERVAL);

}

private function onButtonLeftArrowClick(param1:ButtonEvent) : void

{

this.stopArrowInterval(-1);

}

private function onButtonLeftArrowReleaseOutside(param1:ButtonEvent) : void

{

this.stopArrowInterval(-1);

}

private function stopArrowInterval(param1:int) : void

{

if(this.mIdArrowInterval == -1 || this.mArrowDirection != param1)

{

return;

}

clearInterval(this.mIdArrowInterval);

this.mIdArrowInterval = -1;

}

private function stopKeyArrowInterval(param1:int) : void

{

if(this.mIdKeyArrowInterval == -1 || this.mKeyArrowDirection != param1)

{

return;

}

clearInterval(this.mIdKeyArrowInterval);

this.mIdKeyArrowInterval = -1;

}

private function onArrowInterval() : void

{

if(this.mItemScrollPosition + this.mArrowDirection >= 0)

{

this.scrollToIndex(this.mItemScrollPosition + this.mArrowDirection);

}

else

{

this.scrollToIndex(0);

}

private function onKeyArrowInterval() : void

{

var _loc1_:uint = 0;

if(this.mItemScrollPosition + this.mKeyArrowDirection >= 0)

{

_loc1_ = this.mItemScrollPosition + this.mKeyArrowDirection;

}

this.scrollToIndex(_loc1_);

}

override public function handleInput(param1:InputEvent) : void

{

if(param1.currentTarget != stage)

{

return;

}

if(param1.isDefaultPrevented())

{

return;

}

var _loc2_:InputDetails = param1.details;

var _loc3_:uint = _loc2_.controllerIndex;

switch(_loc2_.navEquivalent)

{

case NavigationCode.RIGHT:

if(_loc2_.value == InputValue.KEY_DOWN)

{

this.mKeyArrowDirection = 1;

this.scrollToIndex(this.mItemScrollPosition + 1);

if(this.mIdKeyArrowInterval == -1)

{

this.mIdKeyArrowInterval = setInterval(this.onKeyArrowInterval,this.ARROW_INTERVAL);

}

else if(_loc2_.value == InputValue.KEY_UP)

{

this.stopKeyArrowInterval(1);

}

break;

case NavigationCode.LEFT:

if(_loc2_.value == InputValue.KEY_DOWN)

{

this.mKeyArrowDirection = -1;

if(this.mItemScrollPosition > 0)

{

this.scrollToIndex(this.mItemScrollPosition - 1);

}

if(this.mIdKeyArrowInterval == -1)

{

this.mIdKeyArrowInterval = setInterval(this.onKeyArrowInterval,this.ARROW_INTERVAL);

}

else if(_loc2_.value == InputValue.KEY_UP)

{

this.stopKeyArrowInterval(-1);

}

break;

}

private function handleMouseUpOnStage(param1:Event) : void

{

this.stopDragging();

}

protected function handleItemPress(param1:Event) : void

{

this.stopTween();

if(this.mIdDraggingInterval != -1)

{

return;

}

this.mLastPressItem = param1.target as UIComponent;

this.mContainerPositionBeforeDrag = container.x;

this.mMouseDownPosition.x = this.mouseX;

this.mMouseDownPosition.y = this.mouseY;

this.mListDragSpeeds.length = 0;

this.mIdDraggingInterval = setInterval(this.onDraggingInterval,this.DRAG_INTERVAL);

this.dispatchItemEvent(param1);

}

override protected function handleItemClick(param1:ButtonEvent) : void

{

if(Math.abs(container.x - this.mContainerPositionBeforeDrag) < 10)

{

super.handleItemClick(param1);

}

this.stopDragging();

}

private function onDraggingInterval() : void

{

var _loc1_:Number = this.mouseX;

var _loc2_:Number = this.mouseY;

var _loc3_:Number = _loc1_ - this.mMouseDownPosition.x;

var _loc4_:Number = container.x + _loc3_;

_loc4_ = this.climbDragPosition(_loc4_);

container.x = Math.round(_loc4_);

var _loc5_:Number = 0;

if(this.mListDragSpeeds.length > 0)

{

_loc5_ = -_loc3_ / this.DRAG_INTERVAL;

if(_loc5_ * this.getAverageLastSpeedDrag() < 0)

{

this.mListDragSpeeds.length = 0;

}

if(this.mListDragSpeeds.length > 10)

{

this.mListDragSpeeds.splice(1,1);

}

this.mListDragSpeeds.push(_loc5_);

this.mMouseDownPosition.x = _loc1_;

this.mMouseDownPosition.y = _loc2_;

}

private function stopDragging() : void

{

var _loc4_:* = 0;

var _loc5_:* = NaN;

var _loc6_:* = NaN;

var _loc7_:* = 0;

if(this.mIdDraggingInterval == -1)

{

return;

}

clearInterval(this.mIdDraggingInterval);

this.mIdDraggingInterval = -1;

var _loc1_:Number = this.getPartByX(container.x);

var _loc2_:Number = (this.countRenderers - this.countVisibleItems) * _loc1_;

var _loc3_:* = 0;

if(_loc1_ >= 0 && _loc1_ <= 1)

{

_loc4_ = Math.floor(_loc2_);

_loc5_ = _loc2_ - _loc4_;

_loc6_ = this.getAverageLastSpeedDrag();

if(_loc5_ > 0.8)

{

_loc3_ = int(Math.ceil(_loc2_));

}

else if(_loc5_ < 0.2)

{

_loc3_ = int(Math.floor(_loc2_));

}

else

{

_loc3_ = _loc6_ > 0?int(Math.ceil(_loc2_)):int(Math.floor(_loc2_));

}

_loc7_ = 0;

while(_loc7_ < this.mSpeedCheck.length)

{

if(_loc6_ >= this.mSpeedCheck[_loc7_])

{

_loc3_ = _loc3_ + (_loc6_ > 0?1:-1);

}

_loc7_++;

}

else

{

_loc3_ = _loc1_ < 0?0:this.countRenderers - this.countVisibleItems;

}

this.mItemScrollPosition = _loc3_;

this.scrollPosition = this.getPartByIndex(_loc3_);

}

[/code][/spoiler]

Report · Jul 06, 2015

Report · Jul 06, 2015

does that code even work?

it looks like code that's been decompiled from someone else's work.

Report · Jul 06, 2015

kglad,

that code works but only with ONE of this Bar or carussel. Now I need a second above the first...

Inside of that bar are 5-6 Pictures what a User can choose to set. Its a bounch of Pictures so 2 rows are better to see more pictures at the same time...

Yes, its with 4 small parts of an other Forum and I have the permission to use these.

But that works totally in a other direction (Threats & Java-Flash movies, I have pictures like a riddle or "memory-Quartett").

cheers

Report · Jul 07, 2015

that's beyond my limit of the amount of code i'll work on in a forum but it looks like the code is referencing a list component. is that the black rectangular object shown at the bottom of your screenshot and is that the place where your single row of objects are displayed?

if yes, there's probably an accessory class (and itemrenderer) that needs to be edited to display two rows.