scrollable
Comment: 'scrollable.func.interface'
scrollable.func.interface
contains all the
information you will
need
scrollable_func_interface
scrollable.func.interface
// Parameters
// anchor (int): provided by natives.galaxy and behaves exactly the same
//const int c_anchorTopLeft = 0;
//const int c_anchorTop = 1;
//const int c_anchorTopRight = 2;
//const int c_anchorLeft = 3;
//const int c_anchorCenter = 4;
//const int c_anchorRight = 5;
//const int c_anchorBottomLeft = 6;
//const int c_anchorBottom = 7;
//const int c_anchorBottomRight = 8;
// disableDragSelect(bool): if set to false, drag select will no longer be turned off while scrolling
// height (int): defines the height of the specified (contentBox/verticalSlider/horizontalSlider) part
// horizontalContentPos(int): scrolls content to the specified horizontal position
// horizontalScrollPercent(fixed): between 0.0 and 1.0; sets the position of the horizontal slider in relation to the maximum
// horizontalSize (int): horizontal content length to set/add to the contentBox
// id (int): identification of your scrollable, gained through "int scrollable_new(string identifier)"
// identifier (string): displayed in error messages
// offsetX (int): defines the horizontal distance from the anchor point
// offsetY (int): defines the vertical distance from the anchor point
// parent (int): can either be a dialog or a dialog control of type "panel"
// parentIsPanel (bool): always behind parent parameter; has to be true if the parent is a panel, false if not
// relativeAnchor (int): same as anchor
// scrollEndFunc (funcref<void func(int horizontalScrollPos, int verticalScrollPos)>): called after a player stops scrolling
// slideXY (bool): if set to true, clicking one slider will activate both at the same time
// targetPlayers (playergroup): group of players that this specific modification should apply to
// verticalContentPos(int): scrolls content to the specified vertical position
// verticalScrollPercent(fixed): between 0.0 and 1.0; sets the position of the vertical slider in relation to the maximum
// verticalSize (int): vertical content length to set/add to the contentBox
// visible (bool): determines whether the target part will be visible or invisible
// width (int): defines the width of the specified (contentBox/verticalSlider/horizontalSlider) part
// Setup
// General
//provides the "id" for a new scrollable
int scrollable_new(string identifier);
//removes an active scrollable
void scrollable_remove(int id);
//reveals or hides the whole scrollable
void scrollable_setVisible(int id, playergroup targetPlayers, bool visible);
//all content has to go in here
//returns dialogControl of type panel
//content box has to be created first
int scrollable_getContentPanel(int id);
//all content that is supposed to move should be relative to one of these
//returns dialogControl
int scrollable_getRelativeControl_top(int id);
int scrollable_getRelativeControl_left(int id);
// Content Box
//creates the contentBox inside the parent
void scrollable_contentBox_create(int id, int parent, bool parentIsPanel);
//sets the size of your contentBox
void scrollable_contentBox_setSize(int id, playergroup targetPlayers, int width, int height);
//sets the position inside the parent
void scrollable_contentBox_setPosition(int id, playergroup targetPlayers, int anchor, int offsetX, int offsetY);
//sets the position relative to another control
void scrollable_contentBox_setPositionRelative(int id, playergroup targetPlayers, int anchor, int relativeControl, int relativeAnchor, int offsetX, int offsetY);
//reveals or hides the whole content box (including border)
void scrollable_contentBox_setVisible(int id, playergroup targetPlayers, bool visible);
//reveals or hides the border around the content box
void scrollable_contentBox_setBorderImageVisible(int id, playergroup targetPlayers, bool visible);
//changes the border image, border image type and border color for the content box
//the border image will always be visible afterwards
//if you did not change the border size the border will be behind the background
void scrollable_contentBox_setBorderImage(int id, playergroup targetPlayers, string image, int imageType, color newColor);
//changes the border size
void scrollable_contentBox_setBorderSize(int id, playergroup targetPlayers, int borderTop, int borderRight, int borderBottom, int BorderLeft);
//reveals or hides the background image inside the content box
void scrollable_contentBox_setBackgroundImageVisible(int id, playergroup targetPlayers, bool visible);
//changes the background image, background image type and background color for the content box
//the background image will always be visible afterwards
void scrollable_contentBox_setBackgroundImage(int id, playergroup targetPlayers, string image, int imageType, color newColor);
//use these to set the width/height of your content; using addXXXContentSize is the prefered method
//the scrollbehavior is undefined for these functions
void scrollable_contentBox_setHorizontalContentSize(int id, playergroup targetPlayers, int horizontalSize);
void scrollable_contentBox_setVerticalContentSize(int id, playergroup targetPlayers, int verticalSize);
void scrollable_contentBox_setContentSize(int id, playergroup targetPlayers, int horizontalSize, int verticalSize);
//use these to add to the width/height of your content
//the visible content will stay visible and won't move if possible
//addLeft(addTop) should be true if the new content is on the left (top) side of your visible (clicked/activated?) content
void scrollable_contentBox_addHorizontalContent(int id, playergroup targetPlayers, int horizontalSize, bool addLeft);
void scrollable_contentBox_addVerticalContent(int id, playergroup targetPlayers, int verticalSize, bool addLeft);
void scrollable_contentBox_addContent(int id, playergroup targetPlayers, int horizontalSize, bool addLeft, int verticalSize, bool addTop);
// Vertical Slider
//creates the vertical slider inside the parent
void scrollable_verticalSlider_create(int id, int parent, bool parentIsPanel);
//sets the size of your vertical slider
void scrollable_verticalSlider_setSize(int id, playergroup targetPlayers, int width, int height, int sliderHeight);
//sets the position inside the parent
void scrollable_verticalSlider_setPosition(int id, playergroup targetPlayers, int anchor, int offsetX, int offsetY);
//sets the position relative to another control
void scrollable_verticalSlider_setPositionRelative(int id, playergroup targetPlayers, int anchor, int relativeControl, int relativeAnchor, int offsetX, int offsetY);
//reveals or hides the whole vertical slider (including border)
void scrollable_verticalSlider_setVisible(int id, playergroup targetPlayers, bool visible);
//reveals or hides the border around the vertical slider
void scrollable_verticalSlider_setBorderImageVisible(int id, playergroup targetPlayers, bool visible);
//changes the border image, border image type and border color for the vertical slider
//the border image will always be visible afterwards
//if you did not change the border size the border will be behind the background
void scrollable_verticalSlider_setBorderImage(int id, playergroup targetPlayers, string image, int imageType, color newColor);
//changes the border size
void scrollable_verticalSlider_setBorderSize(int id, playergroup targetPlayers, int borderTop, int borderRight, int borderBottom, int borderLeft);
//reveals or hides the background image inside the vertical slider
void scrollable_verticalSlider_setBackgroundImageVisible(int id, playergroup targetPlayers, bool visible);
//changes the background image, background image type and background color for the vertical slider
//the background image will always be visible afterwards
void scrollable_verticalSlider_setBackgroundImage(int id, playergroup targetPlayers, string image, int imageType, color newColor);
// Horizontal Slider
//creates the horizontal slider inside the parent
void scrollable_horizontalSlider_create(int id, int parent, bool parentIsPanel);
//sets the size of your horizontal slider
void scrollable_horizontalSlider_setSize(int id, playergroup targetPlayers, int width, int height, int sliderWidth);
//sets the position inside the parent
void scrollable_horizontalSlider_setPosition(int id, playergroup targetPlayers, int anchor, int offsetX, int offsetY);
//sets the position relative to another control
void scrollable_horizontalSlider_setPositionRelative(int id, playergroup targetPlayers, int anchor, int relativeControl, int relativeAnchor, int offsetX, int offsetY);
//reveals or hides the whole horizontal slider (including border)
void scrollable_horizontalSlider_setVisible(int id, playergroup targetPlayers, bool visible);
//reveals or hides the border around the horizontal slider
void scrollable_horizontalSlider_setBorderImageVisible(int id, playergroup targetPlayers, bool visible);
//changes the border image, border image type and border color for the horizontal slider
//the border image will always be visible afterwards
//if you did not change the border size the border will be behind the background
void scrollable_horizontalSlider_setBorderImage(int id, playergroup targetPlayers, string image, int imageType, color newColor);
//changes the border size
void scrollable_horizontalSlider_setBorderSize(int id, playergroup targetPlayers, int borderTop, int borderRight, int borderBottom, int borderLeft);
//reveals or hides the background image inside the horizontal slider
void scrollable_horizontalSlider_setBackgroundImageVisible(int id, playergroup targetPlayers, bool visible);
//changes the background image, background image type and background color for the horizontal slider
//the background image will always be visible afterwards
void scrollable_horizontalSlider_setBackgroundImage(int id, playergroup targetPlayers, string image, int imageType, color newColor);
// Utility
// General
//every scrollable is set to disable drag select by default
//only change if your map disables drag select by default
//drag select is switched ON after the mouse leaves the slider
void scrollable_disableDragSelect(int id, playergroup targetPlayers, bool disableDragSelect);
//if slideXY is turned on, clicking a single slider will enable sliding both directions (both sliders active)
void scrollable_slideXY(int id, playergroup targetPlayers, bool slideXY);
//stops players from changing the scroll position (triggers still work)
void scrollable_lock(int id, playergroup targetPlayers, bool lockHorizontal, bool lockVertical);
//use these to set other dialog controls relative
//the center functions gives back a control that has the size of that specific part without border
//returns a dilog control
int scrollable_contentBox_relative(int id);
int scrollable_verticalSlider_relative(int id);
int scrollable_horizontalSlider_relative(int id);
//sets the sliders to a position relative to the maximum
void scrollable_scrollPosPercent(int id, playergroup targetPlayers, fixed horizontalScrollPercent, fixed verticalScrollPercent);
//sets scrollEndFunc to be called after the player stopped scrolling
//set to "scrollable_dummyFunc" to remove
void scrollable_eventRegisterScrollEnd(int id, playergroup targetPlayers, funcref<dummyFunc> scrollEndFunc);
// Content Box
//moves the content to a specific position
void scrollable_contentBox_setVerticalContentPos(int id, playergroup targetPlayers, int verticalContentPos);
void scrollable_contentBox_setHorizontalContentPos(int id, playergroup targetPlayers, int horizontalContentPos);
void scrollable_contentBox_setContentPos(int id, playergroup targetPlayers, int horizontalContentPos, int verticalContentPos);
//gives you the current position of the content
int scrollable_contentBox_getVerticalContentScrollPos(int id, int player);
int scrollable_contentBox_getHorizontalContentScrollPos(int id, int player);
// Vertical Slider
//stops players from changing the horizontal position (triggers still work)
void scrollable_verticalSlider_lock(int id, playergroup targetPlayers, bool lockVertical);
//sets the sliders to a position relative to the maximum
void scrollable_verticalSlider_scrollPosPercent(int id, playergroup targetPlayers, fixed verticalScrollPercent);
//forces the vertical slider to stay in scroll mode (no matter what the player does)
void scrollable_vertidalSlider_forceScroll(int id, playergroup targetPlayers, bool forced);
// Horizontal Slider
//stops players from changing the horizontal position (triggers still work)
void scrollable_horizontalSlider_lock(int id, playergroup targetPlayers, bool lockHorizontal);
//sets the sliders to a position relative to the maximum
void scrollable_horizontalSlider_scrollPosPercent(int id, playergroup targetPlayers, fixed horizontalScrollPercent);
//forces the horizontal slider to stay in scroll mode (no matter what the player does)
void scrollable_horizontalSlider_forceScroll(int id, playergroup targetPlayers, bool forced);
scrollable_func_impl_horizontalSlider
Untitled Custom Script 001
void scrollable_horizontalSlider_create(int id, int parent, bool parentIsPanel) {
structref<scrollable> sobj = scrollables[id];
int i;
if (sobj.hS) {
TriggerDebugOutput(1, StringToText("ERROR: Trying to create Vertical Slider for " + sobj.identifier + " multiple times."), true);
return;
}
sobj.hSDCBorderImage = scrollable_dCPSI(parent, parentIsPanel, c_triggerControlTypeImage);
sobj.hSDCBackgroundImage = scrollable_dCPSI(parent, parentIsPanel, c_triggerControlTypeImage);
sobj.hSDCSlider = scrollable_dCPSI(parent, parentIsPanel, c_triggerControlTypeImage);
for(i = 0; i < 4; i += 1) {
sobj.hSDCSliderMouseOut[i] = scrollable_dCPSI(parent, parentIsPanel, c_triggerControlTypePanel);
DialogControlSetSize(sobj.hSDCSliderMouseOut[i], scrollableAll, 10000, 10000);
DialogControlSetPropertyAsBool(sobj.hSDCSliderMouseOut[i], c_triggerControlPropertyAcceptMouseTarget, scrollableAll, true);
DialogControlSetPropertyAsFixed(sobj.hSDCSliderMouseOut[i], c_triggerControlPropertyValue, scrollableAll, IntToFixed(id));
TriggerAddEventDialogControl(scrollable_mouseOut_horizontal, -1, sobj.hSDCSliderMouseOut[i], c_triggerControlEventTypeMouseEnter);
}
DialogControlSetPropertyAsBool(sobj.hSDCSlider, c_triggerControlPropertyAcceptMouseTarget, scrollableAll, true);
DialogControlSetPropertyAsFixed(sobj.hSDCSlider, c_triggerControlPropertyValue, scrollableAll, IntToFixed(id));
TriggerAddEventDialogControl(scrollable_mouseIn_horizontal, -1, sobj.hSDCSlider, c_triggerControlEventTypeMouseEnter);
DialogControlSetPositionRelative(sobj.hSDCBackgroundImage, scrollableAll, c_anchorTopLeft, sobj.hSDCBorderImage, c_anchorTopLeft, 0, 0);
DialogControlSetPositionRelative(sobj.hSDCSlider, scrollableAll, c_anchorLeft, sobj.hSDCBackgroundImage, c_anchorLeft, 0, 0);
DialogControlSetPositionRelative(sobj.hSDCSliderMouseOut[0], scrollableAll, c_anchorBottomLeft, sobj.hSDCSlider, c_anchorTopLeft, 0, 0);
DialogControlSetPositionRelative(sobj.hSDCSliderMouseOut[1], scrollableAll, c_anchorTopLeft, sobj.hSDCSlider, c_anchorTopRight, 0, 0);
DialogControlSetPositionRelative(sobj.hSDCSliderMouseOut[2], scrollableAll, c_anchorTopRight, sobj.hSDCSlider, c_anchorBottomRight, 0, 0);
DialogControlSetPositionRelative(sobj.hSDCSliderMouseOut[3], scrollableAll, c_anchorBottomRight, sobj.hSDCSlider, c_anchorBottomLeft, 0, 0);
DialogControlSetPropertyAsColor(sobj.hSDCBackgroundImage, c_triggerControlPropertyColor, scrollableAll, Color(10,10,10));
sobj.hS = true;
}
void scrollable_horizontalSlider_setSize(int id, playergroup targetPlayers, int width, int height, int sliderWidth) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int p;
if (!sobj.hS) {
TriggerDebugOutput(1, StringToText("ERROR: Trying to set size of Vertical Slider that was never created. Identifier = " + sobj.identifier), true);
return;
}
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
p = PlayerGroupPlayer(targetPlayers, loopInt);
PlayerGroupAdd(sobj.hSOwners, p);
sobj.sliderPosMaxX[p] = width - sliderWidth;
if (sobj.hSBorderImageVisible[p]) {
DialogControlSetSize(sobj.hSDCBorderImage, PlayerGroupSingle(p), width + sobj.hSBorderSize[p][c_scrollable_left] + sobj.hSBorderSize[p][c_scrollable_right], height + sobj.hSBorderSize[p][c_scrollable_top] + sobj.hSBorderSize[p][c_scrollable_bottom]);
} else {
DialogControlSetSize(sobj.hSDCBorderImage, PlayerGroupSingle(p), width, height);
}
}
DialogControlSetSize(sobj.hSDCSlider, targetPlayers, sliderWidth, height);
DialogControlSetSize(sobj.hSDCBackgroundImage, targetPlayers, width, height);
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_horizontalSlider_setPosition(int id, playergroup targetPlayers, int anchor, int offsetX, int offsetY) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
DialogControlSetPosition(sobj.hSDCBorderImage, gplayer, anchor, offsetX, offsetY);
}
}
void scrollable_horizontalSlider_setPositionRelative(int id, playergroup targetPlayers, int anchor, int relativeControl, int relativeAnchor, int offsetX, int offsetY) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
DialogControlSetPositionRelative(sobj.hSDCBorderImage, gplayer, anchor, relativeControl, relativeAnchor, offsetX, offsetY);
}
}
void scrollable_horizontalSlider_setBorderSizeByVisibility(int id, playergroup targetPlayers) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
if (sobj.hSBorderImageVisible[player]) {
DialogControlSetSize(sobj.hSDCBorderImage, gplayer,
DialogControlGetPropertyAsInt(sobj.hSDCBackgroundImage, c_triggerControlPropertyWidth, player) + sobj.hSBorderSize[player][c_scrollable_left] + sobj.hSBorderSize[player][c_scrollable_right],
DialogControlGetPropertyAsInt(sobj.hSDCBackgroundImage, c_triggerControlPropertyHeight, player) + sobj.hSBorderSize[player][c_scrollable_top] + sobj.hSBorderSize[player][c_scrollable_bottom]);
DialogControlSetPositionRelative(sobj.hSDCBackgroundImage, gplayer, c_anchorTopLeft, sobj.hSDCBorderImage, c_anchorTopLeft, sobj.hSBorderSize[player][c_scrollable_left], sobj.hSBorderSize[player][c_scrollable_top]);
} else {
DialogControlSetSize(sobj.hSDCBorderImage, gplayer,
DialogControlGetPropertyAsInt(sobj.hSDCBackgroundImage, c_triggerControlPropertyWidth, player),
DialogControlGetPropertyAsInt(sobj.hSDCBackgroundImage, c_triggerControlPropertyHeight, player));
DialogControlSetPositionRelative(sobj.hSDCBackgroundImage, gplayer, c_anchorTopLeft, sobj.hSDCBorderImage, c_anchorTopLeft, 0, 0);
}
}
}
void scrollable_horizontalSlider_setBorderImageVisible(int id, playergroup targetPlayers, bool visible) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
sobj.hSBorderImageVisible[player] = visible;
}
scrollable_horizontalSlider_setBorderSizeByVisibility(id, targetPlayers);
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_horizontalSlider_setBorderImage( int id, playergroup targetPlayers,
string image, int imageType, color newColor) {
structref<scrollable> sobj = scrollables[id];
DialogControlSetPropertyAsString(sobj.hSDCBorderImage, c_triggerControlPropertyImage, targetPlayers, image);
DialogControlSetPropertyAsInt(sobj.hSDCBorderImage, c_triggerControlPropertyImageType, targetPlayers, imageType);
DialogControlSetPropertyAsColor(sobj.hSDCBorderImage, c_triggerControlPropertyColor, targetPlayers, newColor);
scrollable_horizontalSlider_setBorderImageVisible(id, targetPlayers, true);
}
void scrollable_horizontalSlider_setBorderSize(int id, playergroup targetPlayers, int borderTop, int borderRight, int borderBottom, int borderLeft) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
sobj.hSBorderSize[player][c_scrollable_top] = borderTop;
sobj.hSBorderSize[player][c_scrollable_right] = borderRight;
sobj.hSBorderSize[player][c_scrollable_bottom] = borderBottom;
sobj.hSBorderSize[player][c_scrollable_left] = borderLeft;
}
scrollable_horizontalSlider_setBorderSizeByVisibility(id, targetPlayers);
}
void scrollable_horizontalSlider_setBackgroundImageVisible(int id, playergroup targetPlayers, bool visible) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.hSBackgroundImageVisible[player] = visible;
}
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_horizontalSlider_setBackgroundImage( int id, playergroup targetPlayers,
string image, int imageType, color newColor) {
structref<scrollable> sobj = scrollables[id];
DialogControlSetPropertyAsString(sobj.hSDCBackgroundImage, c_triggerControlPropertyImage, targetPlayers, image);
DialogControlSetPropertyAsInt(sobj.hSDCBackgroundImage, c_triggerControlPropertyImageType, targetPlayers, imageType);
DialogControlSetPropertyAsColor(sobj.hSDCBackgroundImage, c_triggerControlPropertyColor, targetPlayers, newColor);
scrollable_horizontalSlider_setBackgroundImageVisible(id, targetPlayers, true);
}
void scrollable_horizontalSlider_setVisible(int id, playergroup targetPlayers, bool visible) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.hSVisible[player] = visible;
}
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_horizontalSlider_lock(int id, playergroup targetPlayers, bool lockHorizontal) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.lockX[player] = lockHorizontal;
}
}
int scrollable_horizontalSlider_relative(int id) {
return scrollables[id].hSDCBorderImage;
}
void scrollable_horizontalSlider_scrollPosPercent(int id, playergroup targetPlayers, fixed horizontalScrollPercent) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
int cPosMaxX;
int cPosX;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
cPosMaxX = sobj.contentScrollPosMaxX[player];
cPosX = FixedToInt(cPosMaxX * horizontalScrollPercent);
sobj.contentScrollPosX[player] = cPosX;
}
scrollable_updateScrollposition(sobj, targetPlayers, false);
}
void scrollable_horizontalSlider_forceScroll(int id, playergroup targetPlayers, bool forced) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
if (forced) {
if (!sobj.forceX[player]) {
sobj.forceX[player] = true;
if (!sobj.forceY[player]) {
scrollable_forceList_add(sobj, player);
}
}
} else if (sobj.forceX[player]) {
if (sobj.forceX[player]) {
sobj.forceX[player] = false;
if (!sobj.forceY[player]) {
scrollable_forceList_remove(sobj, player);
}
}
}
}
}
scrollable.active.impl
bool scrollable_mouseIn_vertical_trig(bool a, bool b) {
int id = FixedToInt(DialogControlGetPropertyAsFixed(EventDialogControl(), c_triggerControlPropertyValue, EventPlayer()));
structref<scrollable> sobj = scrollables[id];
playergroup gplayer = PlayerGroupSingle(EventPlayer());
int i;
sobj.vSIn[EventPlayer()] = true;
DialogControlSetPropertyAsBool(sobj.vSDCSlider, c_triggerControlPropertyAcceptMouseTarget, gplayer, false);
DialogControlSetEnabled(sobj.vSDCSlider, gplayer, false);
for(i = 0; i < 4; i += 1) {
DialogControlSetVisible(sobj.vSDCSliderMouseOut[i], gplayer, true);
}
scrollableActive[EventPlayer()] = id;
if (sobj.disableDragSelect[EventPlayer()]) {
UISetDragSelectEnabled(gplayer, false);
}
UISetSelectionTypeEnabled(gplayer, c_localSelectionTypeWorldPanel, false);
scrollableMouseIsIn[EventPlayer()] += 1;
return true;
}
bool scrollable_mouseOut_vertical_trig(bool a, bool b) {
int id = FixedToInt(DialogControlGetPropertyAsFixed(EventDialogControl(), c_triggerControlPropertyValue, EventPlayer()));
structref<scrollable> sobj = scrollables[id];
playergroup gplayer = PlayerGroupSingle(EventPlayer());
int i;
sobj.vSIn[EventPlayer()] = false;
DialogControlSetPropertyAsBool(sobj.vSDCSlider, c_triggerControlPropertyAcceptMouseTarget, gplayer, true);
DialogControlSetEnabled(sobj.vSDCSlider, gplayer, true);
for(i = 0; i < 4; i += 1) {
DialogControlSetVisible(sobj.vSDCSliderMouseOut[i], gplayer, false);
}
if (scrollableActive[EventPlayer()] == id) {
scrollableActive[EventPlayer()] = -1;
}
if (!scrollableMouseIsDown[EventPlayer()]) {
if (sobj.disableDragSelect[EventPlayer()]) {
UISetDragSelectEnabled(gplayer, true);
}
UISetSelectionTypeEnabled(gplayer, c_localSelectionTypeWorldPanel, true);
}
scrollableMouseIsIn[EventPlayer()] -= 1;
return true;
}
bool scrollable_mouseIn_horizontal_trig(bool a, bool b) {
int id = FixedToInt(DialogControlGetPropertyAsFixed(EventDialogControl(), c_triggerControlPropertyValue, EventPlayer()));
structref<scrollable> sobj = scrollables[id];
playergroup gplayer = PlayerGroupSingle(EventPlayer());
int i;
sobj.hSIn[EventPlayer()] = true;
DialogControlSetPropertyAsBool(sobj.hSDCSlider, c_triggerControlPropertyAcceptMouseTarget, gplayer, false);
DialogControlSetEnabled(sobj.hSDCSlider, gplayer, false);
for(i = 0; i < 4; i += 1) {
DialogControlSetVisible(sobj.hSDCSliderMouseOut[i], gplayer, true);
}
scrollableActive[EventPlayer()] = id;
if (sobj.disableDragSelect[EventPlayer()]) {
UISetDragSelectEnabled(gplayer, false);
}
UISetSelectionTypeEnabled(gplayer, c_localSelectionTypeWorldPanel, false);
scrollableMouseIsIn[EventPlayer()] += 1;
return true;
}
bool scrollable_mouseOut_horizontal_trig(bool a, bool b) {
int id = FixedToInt(DialogControlGetPropertyAsFixed(EventDialogControl(), c_triggerControlPropertyValue, EventPlayer()));
structref<scrollable> sobj = scrollables[id];
playergroup gplayer = PlayerGroupSingle(EventPlayer());
int i;
sobj.hSIn[EventPlayer()] = false;
DialogControlSetPropertyAsBool(sobj.hSDCSlider, c_triggerControlPropertyAcceptMouseTarget, gplayer, true);
DialogControlSetEnabled(sobj.hSDCSlider, gplayer, true);
for(i = 0; i < 4; i += 1) {
DialogControlSetVisible(sobj.hSDCSliderMouseOut[i], gplayer, false);
}
if (scrollableActive[EventPlayer()] == id) {
scrollableActive[EventPlayer()] = -1;
}
if (!scrollableMouseIsDown[EventPlayer()]) {
if (sobj.disableDragSelect[EventPlayer()]) {
UISetDragSelectEnabled(gplayer, true);
}
UISetSelectionTypeEnabled(gplayer, c_localSelectionTypeWorldPanel, true);
}
scrollableMouseIsIn[EventPlayer()] -= 1;
return true;
}
bool scrollable_mouseDown_trig(bool a, bool b) {
structref<scrollable> sobj;
if (scrollableActive[EventPlayer()] > -1) {
sobj = scrollables[scrollableActive[EventPlayer()]];
scrollableMoving[EventPlayer()] = scrollableActive[EventPlayer()];
sobj.vSMoving[EventPlayer()] = sobj.vSIn[EventPlayer()] || sobj.slideXY[EventPlayer()];
sobj.hSMoving[EventPlayer()] = sobj.hSIn[EventPlayer()] || sobj.slideXY[EventPlayer()];
scrollableMouseIsDown[EventPlayer()] = true;
}
return true;
}
bool scrollable_mouseUp_trig(bool a, bool b) {
structref<scrollable> sobj;
playergroup gplayer;
if (scrollableMoving[EventPlayer()] > -1) {
sobj = scrollables[scrollableMoving[EventPlayer()]];
gplayer = PlayerGroupSingle(EventPlayer());
scrollableMoving[EventPlayer()] = -1;
sobj.vSMoving[EventPlayer()] = false;
sobj.hSMoving[EventPlayer()] = false;
if (scrollableMouseIsIn[EventPlayer()] < 1) {
if (sobj.disableDragSelect[EventPlayer()]) {
UISetDragSelectEnabled(gplayer, true);
}
UISetSelectionTypeEnabled(gplayer, c_localSelectionTypeWorldPanel, true);
}
scrollableMouseIsDown[EventPlayer()] = false;
sobj.afterScrolling[EventPlayer()](sobj.contentScrollPosX[EventPlayer()], sobj.contentScrollPosY[EventPlayer()]);
}
return true;
}
void scrollable_move(structref<scrollable> sobj, int player, int amountX, int amountY, bool moveX, bool moveY) {
int sPosX = sobj.sliderPosX[player];
int sPosMaxX = sobj.sliderPosMaxX[player];
int sPosY = sobj.sliderPosY[player];
int sPosMaxY = sobj.sliderPosMaxY[player];
playergroup gplayer = PlayerGroupSingle(player);
if (moveY && (!sobj.lockY[player])) {
sobj.sliderPosY[player] = MinI(sPosMaxY, MaxI(0, sPosY + amountY));
}
if (moveX && (!sobj.lockX[player])) {
sobj.sliderPosX[player] = MinI(sPosMaxX, MaxI(0, sPosX + amountX));
}
scrollable_updateScrollposition(sobj, gplayer, true);
}
bool scrollable_mouseMoved_trig(bool a, bool b) {
structref<scrollable> sobj;
int forced;
int player = EventPlayer();
if (scrollableMoving[player] > -1) {
sobj = scrollables[scrollableMoving[player]];
scrollable_move(sobj, player, EventMouseMovedPosXUI() - scrollableTrackX[player], EventMouseMovedPosYUI() - scrollableTrackY[player], sobj.hSMoving[player], sobj.vSMoving[player]);
}
if (scrollableForceList[player] > -1) {
forced = scrollableForceList[player];
while (forced > -1) {
sobj = scrollables[forced];
if (sobj.id != scrollableMoving[player]) {
scrollable_move(sobj, player, EventMouseMovedPosXUI() - scrollableTrackX[player], EventMouseMovedPosYUI() - scrollableTrackY[player], sobj.forceX[player], sobj.forceY[player]);
} else {
//just move the part that hasn't been moved already
scrollable_move(sobj, player, EventMouseMovedPosXUI() - scrollableTrackX[player], EventMouseMovedPosYUI() - scrollableTrackY[player], sobj.forceX[player] && (!scrollables[scrollableMoving[player]].hSMoving[player]), sobj.forceY[player] && (!scrollables[scrollableMoving[player]].vSMoving[player]));
}
forced = sobj.forceListNext[player];
}
}
scrollableTrackX[EventPlayer()] = EventMouseMovedPosXUI();
scrollableTrackY[EventPlayer()] = EventMouseMovedPosYUI();
return true;
}
void scrollable_initActive() {
TriggerAddEventMouseClicked(scrollable_mouseDown, -1, c_mouseButtonLeft, true);
TriggerAddEventMouseClicked(scrollable_mouseUp, -1, c_mouseButtonLeft, false);
TriggerAddEventMouseMoved(scrollable_mouseMoved, -1);
}
scrollable_initActive
scrollable_func_impl_general
scrollable.func.impl.general
void scrollable_dummyFunc(int a, int b) {}
//dialogcontrolCreateParentedSizedInvisible
int scrollable_dCPSI(int parent, bool parentIsPanel, int controlType) {
int control;
if (parentIsPanel) {
control = DialogControlCreateInPanel(parent, controlType);
} else {
control = DialogControlCreate(parent, controlType);
}
//prevents invalid size error if not for all players
DialogControlSetSize(control, scrollableAll, 1, 1);
DialogControlSetVisible(control, scrollableAll, false);
return control;
}
void scrollable_checkOwnerContent(structref<scrollable> sobj, playergroup targetPlayers) {
int i;
int p;
i = 1;
while (i <= PlayerGroupCount(targetPlayers)) {
p = PlayerGroupPlayer(targetPlayers, i);
if (PlayerGroupHasPlayer(sobj.cBOwners, p)) {
i += 1;
} else {
PlayerGroupRemove(targetPlayers, p);
TriggerDebugOutput(1, StringToText("ERROR: Trying to access Content Box in (" + sobj.identifier + ") for player (" + IntToString(p) + ") who is not an owner. Skipping player."), true);
}
}
}
void scrollable_checkOwnerVertical(structref<scrollable> sobj, playergroup targetPlayers) {
int i;
int p;
i = 1;
while (i <= PlayerGroupCount(targetPlayers)) {
p = PlayerGroupPlayer(targetPlayers, i);
if (PlayerGroupHasPlayer(sobj.vSOwners, p)) {
i += 1;
} else {
PlayerGroupRemove(targetPlayers, p);
TriggerDebugOutput(1, StringToText("ERROR: Trying to access Vertical Slider in (" + sobj.identifier + ") for player (" + IntToString(p) + ") who is not an owner. Skipping player."), true);
}
}
}
void scrollable_checkOwnerHorizontal(structref<scrollable> sobj, playergroup targetPlayers) {
int i;
int p;
i = 1;
while (i <= PlayerGroupCount(targetPlayers)) {
p = PlayerGroupPlayer(targetPlayers, i);
if (PlayerGroupHasPlayer(sobj.hSOwners, p)) {
i += 1;
} else {
PlayerGroupRemove(targetPlayers, p);
TriggerDebugOutput(1, StringToText("ERROR: Trying to access HorizontalSlider in (" + sobj.identifier + ") for player (" + IntToString(p) + ") who is not an owner. Skipping player."), true);
}
}
}
void scrollable_resetVisibility(int id, playergroup targetPlayers) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
bool visible;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
if (sobj.cB) {
visible = (sobj.visible[player] && sobj.cBVisible[player]);
DialogControlSetVisible(sobj.cBDCBackgroundImage, gplayer, visible && sobj.cBBackgroundImageVisible[player]);
DialogControlSetVisible(sobj.cBDCBorderImage, gplayer, visible && sobj.cBBorderImageVisible[player]);
DialogControlSetVisible(sobj.cBDCContentBox, gplayer, visible);
}
if (sobj.vS) {
visible = (sobj.visible[player] && sobj.vSVisible[player]);
DialogControlSetVisible(sobj.vSDCBackgroundImage, gplayer, visible && sobj.vSBackgroundImageVisible[player]);
DialogControlSetVisible(sobj.vSDCBorderImage, gplayer, visible && sobj.vSBorderImageVisible[player]);
DialogControlSetVisible(sobj.vSDCSlider, gplayer, visible);
}
if (sobj.hS) {
visible = (sobj.visible[player] && sobj.hSVisible[player]);
DialogControlSetVisible(sobj.hSDCBackgroundImage, gplayer, visible && sobj.hSBackgroundImageVisible[player]);
DialogControlSetVisible(sobj.hSDCBorderImage, gplayer, visible && sobj.hSBackgroundImageVisible[player]);
DialogControlSetVisible(sobj.hSDCSlider, gplayer, visible);
}
}
}
void scrollable_updateScrollposition(structref<scrollable> sobj, playergroup targetPlayers, bool bySliderPosition) {
int loopInt;
int player;
int sPosX;
int sPosMaxX;
int sPosY;
int sPosMaxY;
int cPosX;
int cPosMaxX;
int cPosY;
int cPosMaxY;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
sPosX = sobj.sliderPosX[player];
sPosMaxX = sobj.sliderPosMaxX[player];
sPosY = sobj.sliderPosY[player];
sPosMaxY = sobj.sliderPosMaxY[player];
cPosX = sobj.contentScrollPosX[player];
cPosMaxX = sobj.contentScrollPosMaxX[player];
cPosY = sobj.contentScrollPosY[player];
cPosMaxY = sobj.contentScrollPosMaxY[player];
if (sobj.vS) {
if (bySliderPosition) {
cPosY = cPosMaxY * sPosY / sPosMaxY;
} else {
if (cPosMaxY > 0) {
sPosY = sPosMaxY * cPosY / cPosMaxY;
} else {
sPosY = 0;
}
}
DialogControlSetPositionRelative(sobj.vSDCSlider, gplayer, c_anchorTop, sobj.vSDCBackgroundImage, c_anchorTop, 0, sPosY);
sobj.sliderPosY[player] = sPosY;
} else {
cPosY = 0;
}
if (sobj.hS) {
if (bySliderPosition) {
cPosX = cPosMaxX * sPosX / sPosMaxX;
} else {
if (cPosMaxX > 0) {
sPosX = sPosMaxX * cPosX / cPosMaxX;
} else {
sPosX = 0;
}
}
DialogControlSetPositionRelative(sobj.hSDCSlider, gplayer, c_anchorLeft, sobj.hSDCBackgroundImage, c_anchorLeft, sPosX, 0);
sobj.sliderPosX[player] = sPosX;
} else {
cPosX = 0;
}
DialogControlSetPosition(sobj.cBDCContentMover, gplayer, c_anchorTopLeft, - cPosX, - cPosY);
sobj.sliderPosX[player] = sPosX;
sobj.sliderPosY[player] = sPosY;
sobj.contentScrollPosX[player] = cPosX;
sobj.contentScrollPosY[player] = cPosY;
}
}
int scrollable_new(string identifier) {
int nscrollable;
structref<scrollable> sobj;
int i;
if (scrollableStack > -1) {
nscrollable = scrollableStack;
scrollableStack = scrollables[nscrollable].stackValue;
} else {
scrollableCount += 1;
nscrollable = scrollableCount;
if (scrollableCount >= c_scrollableCount) {
TriggerDebugOutput(1, StringToText("ERROR: Trying to allocate scrollable number " + IntToString(nscrollable + 1) + " of " + IntToString(c_scrollableCount) + "."), true);
TriggerDebugOutput(1, StringToText("Go to scrollable->scrollable.varspace and adjust the constant \"c_scrollableCount\"."), true);
return -1;
}
}
sobj = scrollables[nscrollable];
sobj.id = nscrollable;
sobj.identifier = identifier;
sobj.cB = false;
sobj.vS = false;
sobj.hS = false;
sobj.cBOwners = PlayerGroupEmpty();
sobj.vSOwners = PlayerGroupEmpty();
sobj.hSOwners = PlayerGroupEmpty();
for (i = 0; i < 16; i += 1) {
sobj.visible[i] = true;
sobj.slideXY[i] = false;
sobj.disableDragSelect[i] = true;
sobj.cBVisible[i] = true;
sobj.cBBackgroundImageVisible[i] = true;
sobj.cBBorderImageVisible[i] = false;
sobj.vSVisible[i] = true;
sobj.vSBackgroundImageVisible[i] = true;
sobj.vSBorderImageVisible[i] = false;
sobj.hSVisible[i] = true;
sobj.hSBackgroundImageVisible[i] = true;
sobj.hSBorderImageVisible[i] = false;
sobj.lockX[i] = false;
sobj.lockY[i] = false;
sobj.forceX[i] = false;
sobj.forceY[i] = false;
sobj.vSMoving[i] = false;
sobj.hSMoving[i] = false;
sobj.vSIn[i] = false;
sobj.hSIn[i] = false;
sobj.afterScrolling[i] = scrollable_dummyFunc;
}
return nscrollable;
}
void scrollable_forceList_remove(structref<scrollable> sobj, int player);
void scrollable_remove(int id) {
structref<scrollable> sobj = scrollables[id];
int player;
if (sobj.cB) {
DialogControlDestroy(sobj.cBDCBackgroundImage);
DialogControlDestroy(sobj.cBDCBorderImage);
DialogControlDestroy(sobj.cBDCContentMover);
DialogControlDestroy(sobj.cBDCContentMoverTop);
DialogControlDestroy(sobj.cBDCContentMoverLeft);
DialogControlDestroy(sobj.cBDCContentBox);
}
if (sobj.vS) {
DialogControlDestroy(sobj.vSDCBackgroundImage);
DialogControlDestroy(sobj.vSDCBorderImage);
DialogControlDestroy(sobj.vSDCSlider);
}
if (sobj.hS) {
DialogControlDestroy(sobj.hSDCBackgroundImage);
DialogControlDestroy(sobj.hSDCBorderImage);
DialogControlDestroy(sobj.hSDCSlider);
}
for (player = 0; player < 16; player += 1) {
if (sobj.forceX[player] || sobj.forceY[player]) {
scrollable_forceList_remove(sobj, player);
}
}
sobj.stackValue = scrollableStack;
scrollableStack = id;
}
void scrollable_setVisible( int id, playergroup targetPlayers, bool visible) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.visible[player] = visible;
}
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_disableDragSelect(int id, playergroup targetPlayers, bool disable){
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.disableDragSelect[player] = disable;
}
}
void scrollable_slideXY( int id, playergroup targetPlayers, bool slideXY) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.slideXY[player] = slideXY;
}
}
void scrollable_lock(int id, playergroup targetPlayers, bool lockHorizontal, bool lockVertical) {
scrollable_horizontalSlider_lock(id, targetPlayers, lockHorizontal);
scrollable_verticalSlider_lock(id, targetPlayers, lockVertical);
}
int scrollable_getContentPanel(int id) {
return scrollables[id].cBDCContentBox;
}
int scrollable_getRelativeControl_top(int id) {
return scrollables[id].cBDCContentMoverTop;
}
int scrollable_getRelativeControl_left(int id) {
return scrollables[id].cBDCContentMoverLeft;
}
void scrollable_scrollPosPercent(int id, playergroup targetPlayers, fixed horizontalScrollPercent, fixed verticalScrollPercent) {
scrollable_horizontalSlider_scrollPosPercent(id, targetPlayers, horizontalScrollPercent);
scrollable_verticalSlider_scrollPosPercent(id, targetPlayers, verticalScrollPercent);
}
void scrollable_contentBox_setContentPos(int id, playergroup targetPlayers, int horizontalContentPos, int verticalContentPos) {
scrollable_contentBox_setHorizontalContentPos(id, targetPlayers, horizontalContentPos);
scrollable_contentBox_setVerticalContentPos(id, targetPlayers, verticalContentPos);
}
void scrollable_contentBox_setVerticalContentPos(int id, playergroup targetPlayers, int verticalContentPos) { structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.contentScrollPosY[player] = verticalContentPos;
}
scrollable_updateScrollposition(sobj, targetPlayers, false);
}
void scrollable_contentBox_setHorizontalContentPos(int id, playergroup targetPlayers, int horizontalContentPos) { structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.contentScrollPosX[player] = horizontalContentPos;
}
scrollable_updateScrollposition(sobj, targetPlayers, false);
}
void scrollable_eventRegisterScrollEnd(int id, playergroup targetPlayers, funcref<dummyFunc> scrollEndFunc) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.afterScrolling[player] = scrollEndFunc;
}
}
void scrollable_forceList_add(structref<scrollable> sobj, int player) {
sobj.forceListNext[player] = scrollableForceList[player];
sobj.forceListPrevious[player] = -1;
if (scrollableForceList[player] != -1) {
scrollables[scrollableForceList[player]].forceListPrevious[player] = sobj.id;
}
scrollableForceList[player] = sobj.id;
}
void scrollable_forceList_remove(structref<scrollable> sobj, int player) {
structref<scrollable> next;
structref<scrollable> previous;
if (sobj.forceListNext[player] > -1) {
next = scrollables[sobj.forceListNext[player]];
if (sobj.forceListPrevious[player] > -1) {
previous = scrollables[sobj.forceListPrevious[player]];
next.forceListPrevious[player] = previous.id;
previous.forceListNext[player] = next.id;
} else {
next.forceListPrevious[player] = -1;
scrollableForceList[player] = next.id;
}
} else if (sobj.forceListPrevious[player] > -1) {
previous = scrollables[sobj.forceListPrevious[player]];
previous.forceListNext[player] = -1;
} else {
scrollableForceList[player] = -1;
}
}
scrollable_func_impl_verticalSlider
Untitled Custom Script 001
void scrollable_verticalSlider_create(int id, int parent, bool parentIsPanel) {
structref<scrollable> sobj = scrollables[id];
int i;
if (sobj.vS) {
TriggerDebugOutput(1, StringToText("ERROR: Trying to create Vertical Slider for " + sobj.identifier + " multiple times."), true);
return;
}
sobj.vSDCBorderImage = scrollable_dCPSI(parent, parentIsPanel, c_triggerControlTypeImage);
sobj.vSDCBackgroundImage = scrollable_dCPSI(parent, parentIsPanel, c_triggerControlTypeImage);
sobj.vSDCSlider = scrollable_dCPSI(parent, parentIsPanel, c_triggerControlTypeImage);
for(i = 0; i < 4; i += 1) {
sobj.vSDCSliderMouseOut[i] = scrollable_dCPSI(parent, parentIsPanel, c_triggerControlTypePanel);
DialogControlSetSize(sobj.vSDCSliderMouseOut[i], scrollableAll, 10000, 10000);
DialogControlSetPropertyAsBool(sobj.vSDCSliderMouseOut[i], c_triggerControlPropertyAcceptMouseTarget, scrollableAll, true);
DialogControlSetPropertyAsFixed(sobj.vSDCSliderMouseOut[i], c_triggerControlPropertyValue, scrollableAll, IntToFixed(id));
TriggerAddEventDialogControl(scrollable_mouseOut_vertical, -1, sobj.vSDCSliderMouseOut[i], c_triggerControlEventTypeMouseEnter);
}
DialogControlSetPropertyAsBool(sobj.vSDCSlider, c_triggerControlPropertyAcceptMouseTarget, scrollableAll, true);
DialogControlSetPropertyAsFixed(sobj.vSDCSlider, c_triggerControlPropertyValue, scrollableAll, IntToFixed(id));
TriggerAddEventDialogControl(scrollable_mouseIn_vertical, -1, sobj.vSDCSlider, c_triggerControlEventTypeMouseEnter);
DialogControlSetPositionRelative(sobj.vSDCBackgroundImage, scrollableAll, c_anchorTopLeft, sobj.vSDCBorderImage, c_anchorTopLeft, 0, 0);
DialogControlSetPositionRelative(sobj.vSDCSlider, scrollableAll, c_anchorTop, sobj.vSDCBackgroundImage, c_anchorTop, 0, 0);
DialogControlSetPositionRelative(sobj.vSDCSliderMouseOut[0], scrollableAll, c_anchorBottomLeft, sobj.vSDCSlider, c_anchorTopLeft, 0, 0);
DialogControlSetPositionRelative(sobj.vSDCSliderMouseOut[1], scrollableAll, c_anchorTopLeft, sobj.vSDCSlider, c_anchorTopRight, 0, 0);
DialogControlSetPositionRelative(sobj.vSDCSliderMouseOut[2], scrollableAll, c_anchorTopRight, sobj.vSDCSlider, c_anchorBottomRight, 0, 0);
DialogControlSetPositionRelative(sobj.vSDCSliderMouseOut[3], scrollableAll, c_anchorBottomRight, sobj.vSDCSlider, c_anchorBottomLeft, 0, 0);
DialogControlSetPropertyAsColor(sobj.vSDCBackgroundImage, c_triggerControlPropertyColor, scrollableAll, Color(10,10,10));
sobj.vS = true;
}
void scrollable_verticalSlider_setSize(int id, playergroup targetPlayers, int width, int height, int sliderHeight) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int p;
if (!sobj.vS) {
TriggerDebugOutput(1, StringToText("ERROR: Trying to set size of Vertical Slider that was never created. Identifier = " + sobj.identifier), true);
return;
}
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
p = PlayerGroupPlayer(targetPlayers, loopInt);
PlayerGroupAdd(sobj.vSOwners, p);
sobj.sliderPosMaxY[p] = height - sliderHeight;
if (sobj.vSBorderImageVisible[p]) {
DialogControlSetSize(sobj.vSDCBorderImage, PlayerGroupSingle(p), width + sobj.vSBorderSize[p][c_scrollable_left] + sobj.vSBorderSize[p][c_scrollable_right], height + sobj.vSBorderSize[p][c_scrollable_top] + sobj.vSBorderSize[p][c_scrollable_bottom]);
} else {
DialogControlSetSize(sobj.vSDCBorderImage, PlayerGroupSingle(p), width, height);
}
}
DialogControlSetSize(sobj.vSDCSlider, targetPlayers, width, sliderHeight);
DialogControlSetSize(sobj.vSDCBackgroundImage, targetPlayers, width, height);
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_verticalSlider_setPosition(int id, playergroup targetPlayers, int anchor, int offsetX, int offsetY) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
DialogControlSetPosition(sobj.vSDCBorderImage, gplayer, anchor, offsetX, offsetY);
}
}
void scrollable_verticalSlider_setPositionRelative(int id, playergroup targetPlayers, int anchor, int relativeControl, int relativeAnchor, int offsetX, int offsetY) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
DialogControlSetPositionRelative(sobj.vSDCBorderImage, gplayer, anchor, relativeControl, relativeAnchor, offsetX, offsetY);
}
}
void scrollable_verticalSlider_setBorderSizeByVisibility(int id, playergroup targetPlayers) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
if (sobj.vSBorderImageVisible[player]) {
DialogControlSetSize(sobj.vSDCBorderImage, gplayer,
DialogControlGetPropertyAsInt(sobj.vSDCBackgroundImage, c_triggerControlPropertyWidth, player) + sobj.vSBorderSize[player][c_scrollable_left] + sobj.vSBorderSize[player][c_scrollable_right],
DialogControlGetPropertyAsInt(sobj.vSDCBackgroundImage, c_triggerControlPropertyHeight, player) + sobj.vSBorderSize[player][c_scrollable_top] + sobj.vSBorderSize[player][c_scrollable_bottom]);
DialogControlSetPositionRelative(sobj.vSDCBackgroundImage, gplayer, c_anchorTopLeft, sobj.vSDCBorderImage, c_anchorTopLeft, sobj.vSBorderSize[player][c_scrollable_left], sobj.vSBorderSize[player][c_scrollable_top]);
} else {
DialogControlSetSize(sobj.vSDCBorderImage, gplayer,
DialogControlGetPropertyAsInt(sobj.vSDCBackgroundImage, c_triggerControlPropertyWidth, player),
DialogControlGetPropertyAsInt(sobj.vSDCBackgroundImage, c_triggerControlPropertyHeight, player));
DialogControlSetPositionRelative(sobj.vSDCBackgroundImage, gplayer, c_anchorTopLeft, sobj.vSDCBorderImage, c_anchorTopLeft, 0, 0);
}
}
}
void scrollable_verticalSlider_setBorderImageVisible(int id, playergroup targetPlayers, bool visible) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
sobj.vSBorderImageVisible[player] = visible;
}
scrollable_verticalSlider_setBorderSizeByVisibility(id, targetPlayers);
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_verticalSlider_setBorderImage( int id, playergroup targetPlayers,
string image, int imageType, color newColor) {
structref<scrollable> sobj = scrollables[id];
DialogControlSetPropertyAsString(sobj.vSDCBorderImage, c_triggerControlPropertyImage, targetPlayers, image);
DialogControlSetPropertyAsInt(sobj.vSDCBorderImage, c_triggerControlPropertyImageType, targetPlayers, imageType);
DialogControlSetPropertyAsColor(sobj.vSDCBorderImage, c_triggerControlPropertyColor, targetPlayers, newColor);
scrollable_verticalSlider_setBorderImageVisible(id, targetPlayers, true);
}
void scrollable_verticalSlider_setBorderSize(int id, playergroup targetPlayers, int borderTop, int borderRight, int borderBottom, int borderLeft) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
sobj.vSBorderSize[player][c_scrollable_top] = borderTop;
sobj.vSBorderSize[player][c_scrollable_right] = borderRight;
sobj.vSBorderSize[player][c_scrollable_bottom] = borderBottom;
sobj.vSBorderSize[player][c_scrollable_left] = borderLeft;
}
scrollable_verticalSlider_setBorderSizeByVisibility(id, targetPlayers);
}
void scrollable_verticalSlider_setBackgroundImageVisible(int id, playergroup targetPlayers, bool visible) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.vSBackgroundImageVisible[player] = visible;
}
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_verticalSlider_setBackgroundImage( int id, playergroup targetPlayers,
string image, int imageType, color newColor) {
structref<scrollable> sobj = scrollables[id];
DialogControlSetPropertyAsString(sobj.vSDCBackgroundImage, c_triggerControlPropertyImage, targetPlayers, image);
DialogControlSetPropertyAsInt(sobj.vSDCBackgroundImage, c_triggerControlPropertyImageType, targetPlayers, imageType);
DialogControlSetPropertyAsColor(sobj.vSDCBackgroundImage, c_triggerControlPropertyColor, targetPlayers, newColor);
scrollable_verticalSlider_setBackgroundImageVisible(id, targetPlayers, true);
}
void scrollable_verticalSlider_setVisible(int id, playergroup targetPlayers, bool visible) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.vSVisible[player] = visible;
}
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_verticalSlider_lock(int id, playergroup targetPlayers, bool lockVertical) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.lockY[player] = lockVertical;
}
}
int scrollable_verticalSlider_relative(int id) {
return scrollables[id].vSDCBorderImage;
}
void scrollable_verticalSlider_scrollPosPercent(int id, playergroup targetPlayers, fixed verticalScrollPercent) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
int cPosMaxY;
int cPosY;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
cPosMaxY = sobj.contentScrollPosMaxY[player];
cPosY = FixedToInt(cPosMaxY * verticalScrollPercent);
sobj.contentScrollPosY[player] = cPosY;
}
scrollable_updateScrollposition(sobj, targetPlayers, false);
}
void scrollable_verticalSlider_forceScroll(int id, playergroup targetPlayers, bool forced) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
if (forced) {
if (!sobj.forceY[player]) {
sobj.forceY[player] = true;
if (!sobj.forceX[player]) {
scrollable_forceList_add(sobj, player);
}
}
} else if (sobj.forceY[player]) {
if (sobj.forceY[player]) {
sobj.forceY[player] = false;
if (!sobj.forceX[player]) {
scrollable_forceList_remove(sobj, player);
}
}
}
}
}
scrollable.varspace
//public
const int c_scrollableCount = 10;
//internal
//global
int[16] scrollableActive;
int[16] scrollableMoving;
int[16] scrollableTrackX;
int[16] scrollableTrackY;
int[16] scrollableMouseIsIn;
bool[16] scrollableMouseIsDown;
int[16] scrollableForceList;
//scrollable
scrollable[c_scrollableCount] scrollables;
int scrollableCount = -1;
int scrollableStack = -1;
//undefined
playergroup scrollableAll = PlayerGroupAll();
const int c_scrollable_top = 0;
const int c_scrollable_right = 1;
const int c_scrollable_bottom = 2;
const int c_scrollable_left = 3;
void scrollableInitVarspace() {
int i;
for (i = 0; i < 16; i += 1) {
scrollableActive[i] = -1;
scrollableMoving[i] = -1;
scrollableMouseIsIn[i] = 0;
scrollableMouseIsDown[i] = false;
scrollableForceList[i] = -1;
}
}
scrollableInitVarspace
scrollable_func_impl_contentBox
scrollable.func.impl.contentBox
void scrollable_contentBox_create(int id, int parent, bool parentIsPanel) {
structref<scrollable> sobj = scrollables[id];
if (sobj.cB) {
TriggerDebugOutput(1, StringToText("ERROR: Trying to create Content Box for " + sobj.identifier + " multiple times."), true);
return;
}
sobj.cBDCBorderImage = scrollable_dCPSI(parent, parentIsPanel, c_triggerControlTypeImage);
sobj.cBDCContentBox = scrollable_dCPSI(parent, parentIsPanel, c_triggerControlTypePanel);
sobj.cBDCBackgroundImage = scrollable_dCPSI(sobj.cBDCContentBox, true, c_triggerControlTypeImage);
sobj.cBDCContentMover = scrollable_dCPSI(sobj.cBDCContentBox, true, c_triggerControlTypePanel);
sobj.cBDCContentMoverTop = scrollable_dCPSI(sobj.cBDCContentBox, true, c_triggerControlTypePanel);
sobj.cBDCContentMoverLeft = scrollable_dCPSI(sobj.cBDCContentBox, true, c_triggerControlTypePanel);
DialogControlSetFullDialog(sobj.cBDCBackgroundImage, scrollableAll, true);
DialogControlSetPropertyAsColor(sobj.cBDCBackgroundImage, c_triggerControlPropertyColor, scrollableAll, Color(0,0,0));
DialogControlSetPositionRelative(sobj.cBDCContentBox, scrollableAll, c_anchorTopLeft, sobj.cBDCBorderImage, c_anchorTopLeft, 0, 0);
DialogControlSetPosition(sobj.cBDCContentMover, scrollableAll, c_anchorTopLeft, 0, 0);
DialogControlSetPositionRelative(sobj.cBDCContentMoverTop, scrollableAll, c_anchorBottomLeft, sobj.cBDCContentMover, c_anchorTopLeft, 0, 0);
DialogControlSetPositionRelative(sobj.cBDCContentMoverLeft, scrollableAll, c_anchorTopRight, sobj.cBDCContentMover, c_anchorTopLeft, 0, 0);
sobj.cB = true;
}
void scrollable_contentBox_setSize(int id, playergroup targetPlayers, int width, int height) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int p;
if (!sobj.cB) {
TriggerDebugOutput(1, StringToText("ERROR: Trying to set size of Content Box that was never created. Identifier = " + sobj.identifier), true);
return;
}
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
p = PlayerGroupPlayer(targetPlayers, loopInt);
PlayerGroupAdd(sobj.cBOwners, p);
sobj.contentBoxWidth[p] = width;
sobj.contentBoxHeight[p] = height;
if (sobj.cBBorderImageVisible[p]) {
DialogControlSetSize(sobj.cBDCBorderImage, PlayerGroupSingle(p), width + sobj.cBBorderSize[p][c_scrollable_left] + sobj.cBBorderSize[p][c_scrollable_right], height + sobj.cBBorderSize[p][c_scrollable_top] + sobj.cBBorderSize[p][c_scrollable_bottom]);
} else {
DialogControlSetSize(sobj.cBDCBorderImage, PlayerGroupSingle(p), width, height);
}
}
DialogControlSetSize(sobj.cBDCContentBox, targetPlayers, width, height);
DialogControlSetSize(sobj.cBDCContentMoverTop, targetPlayers, width, 1);
DialogControlSetSize(sobj.cBDCContentMoverLeft, targetPlayers, 1, height);
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_contentBox_setPosition(int id, playergroup targetPlayers, int anchor, int offsetX, int offsetY) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt < PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
DialogControlSetPosition(sobj.cBDCBorderImage, gplayer, anchor, offsetX, offsetY);
}
}
void scrollable_contentBox_setPositionRelative(int id, playergroup targetPlayers, int anchor, int relativeControl, int relativeAnchor, int offsetX, int offsetY) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
DialogControlSetPositionRelative(sobj.cBDCBorderImage, gplayer, anchor, relativeControl, relativeAnchor, offsetX, offsetY);
}
}
void scrollable_contentBox_setBorderSizeByVisibility(int id, playergroup targetPlayers) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
if (sobj.cBBorderImageVisible[player]) {
DialogControlSetSize(sobj.cBDCBorderImage, gplayer,
DialogControlGetPropertyAsInt(sobj.cBDCContentBox, c_triggerControlPropertyWidth, player) + sobj.cBBorderSize[player][c_scrollable_left] + sobj.cBBorderSize[player][c_scrollable_right],
DialogControlGetPropertyAsInt(sobj.cBDCContentBox, c_triggerControlPropertyHeight, player) + sobj.cBBorderSize[player][c_scrollable_top] + sobj.cBBorderSize[player][c_scrollable_bottom]);
DialogControlSetPositionRelative(sobj.cBDCContentBox, gplayer, c_anchorTopLeft, sobj.cBDCBorderImage, c_anchorTopLeft, sobj.cBBorderSize[player][c_scrollable_left], sobj.cBBorderSize[player][c_scrollable_top]);
} else {
DialogControlSetSize(sobj.cBDCBorderImage, gplayer,
DialogControlGetPropertyAsInt(sobj.cBDCContentBox, c_triggerControlPropertyWidth, player),
DialogControlGetPropertyAsInt(sobj.cBDCContentBox, c_triggerControlPropertyHeight, player));
DialogControlSetPositionRelative(sobj.cBDCContentBox, gplayer, c_anchorTopLeft, sobj.cBDCBorderImage, c_anchorTopLeft, 0, 0);
}
}
}
void scrollable_contentBox_setBorderImageVisible(int id, playergroup targetPlayers, bool visible) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.cBBorderImageVisible[player] = visible;
}
scrollable_contentBox_setBorderSizeByVisibility(id, targetPlayers);
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_contentBox_setBorderImage(int id, playergroup targetPlayers, string image, int imageType, color newColor) {
structref<scrollable> sobj = scrollables[id];
DialogControlSetPropertyAsString(sobj.cBDCBorderImage, c_triggerControlPropertyImage, targetPlayers, image);
DialogControlSetPropertyAsInt(sobj.cBDCBorderImage, c_triggerControlPropertyImageType, targetPlayers, imageType);
DialogControlSetPropertyAsColor(sobj.cBDCBorderImage, c_triggerControlPropertyColor, targetPlayers, newColor);
scrollable_contentBox_setBorderImageVisible(id, targetPlayers, true);
}
void scrollable_contentBox_setBorderSize(int id, playergroup targetPlayers, int borderTop, int borderRight, int borderBottom, int borderLeft) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
playergroup gplayer;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
gplayer = PlayerGroupSingle(player);
sobj.cBBorderSize[player][c_scrollable_top] = borderTop;
sobj.cBBorderSize[player][c_scrollable_right] = borderRight;
sobj.cBBorderSize[player][c_scrollable_bottom] = borderBottom;
sobj.cBBorderSize[player][c_scrollable_left] = borderLeft;
}
scrollable_contentBox_setBorderSizeByVisibility(id, targetPlayers);
}
void scrollable_contentBox_setBackgroundImageVisible(int id, playergroup targetPlayers, bool visible) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.cBBackgroundImageVisible[player] = visible;
}
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_contentBox_setBackgroundImage(int id, playergroup targetPlayers, string image, int imageType, color newColor) {
structref<scrollable> sobj = scrollables[id];
DialogControlSetPropertyAsString(sobj.cBDCBackgroundImage, c_triggerControlPropertyImage, targetPlayers, image);
DialogControlSetPropertyAsInt(sobj.cBDCBackgroundImage, c_triggerControlPropertyImageType, targetPlayers, imageType);
DialogControlSetPropertyAsColor(sobj.cBDCBackgroundImage, c_triggerControlPropertyColor, targetPlayers, newColor);
scrollable_contentBox_setBackgroundImageVisible(id, targetPlayers, true);
}
void scrollable_contentBox_setVisible(int id, playergroup targetPlayers, bool visible) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.cBVisible[player] = visible;
}
scrollable_resetVisibility(id, targetPlayers);
}
void scrollable_contentBox_setHorizontalContentSize(int id, playergroup targetPlayers, int horizontalSize) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.contentWidth[player] = horizontalSize;
sobj.contentScrollPosMaxX[player] = horizontalSize - sobj.contentBoxWidth[player];
}
}
void scrollable_contentBox_setVerticalContentSize(int id, playergroup targetPlayers, int verticalSize) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.contentHeight[player] = verticalSize;
sobj.contentScrollPosMaxY[player] = verticalSize - sobj.contentBoxHeight[player];
}
}
void scrollable_contentBox_setContentSize(int id, playergroup targetPlayers, int horizontalSize, int verticalSize) {
scrollable_contentBox_setHorizontalContentSize(id, targetPlayers, horizontalSize);
scrollable_contentBox_setVerticalContentSize(id, targetPlayers, verticalSize);
}
void scrollable_contentBox_addHorizontalContent(int id, playergroup targetPlayers, int horizontalSize, bool addLeft) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.contentWidth[player] += horizontalSize;
sobj.contentScrollPosMaxX[player] = MaxI(0, sobj.contentWidth[player] - sobj.contentBoxWidth[player]);
if (addLeft) {
sobj.contentScrollPosX[player] += horizontalSize;
}
sobj.contentScrollPosX[player] = MaxI(0, MinI(sobj.contentScrollPosMaxX[player], sobj.contentScrollPosX[player]));
}
scrollable_updateScrollposition(sobj, targetPlayers, false);
}
void scrollable_contentBox_addVerticalContent(int id, playergroup targetPlayers, int verticalSize, bool addTop) {
structref<scrollable> sobj = scrollables[id];
int loopInt;
int player;
for (loopInt = 1; loopInt <= PlayerGroupCount(targetPlayers); loopInt += 1) {
player = PlayerGroupPlayer(targetPlayers, loopInt);
sobj.contentHeight[player] += verticalSize;
sobj.contentScrollPosMaxY[player] = MaxI(0, sobj.contentHeight[player] - sobj.contentBoxHeight[player]);
if (addTop) {
sobj.contentScrollPosY[player] += verticalSize;
}
sobj.contentScrollPosY[player] = MaxI(0, MinI(sobj.contentScrollPosMaxY[player], sobj.contentScrollPosY[player]));
}
scrollable_updateScrollposition(sobj, targetPlayers, false);
}
void scrollable_contentBox_addContent(int id, playergroup targetPlayers, int horizontalSize, bool addLeft, int verticalSize, bool addTop) {
scrollable_contentBox_addHorizontalContent(id, targetPlayers, horizontalSize, addLeft);
scrollable_contentBox_addVerticalContent(id, targetPlayers, verticalSize, addTop);
}
int scrollable_contentBox_relative(int id) {
return scrollables[id].cBDCBorderImage;
}
int scrollable_contentBox_getHorizontalContentScrollPos(int id, int player) {
return scrollables[id].contentScrollPosX[player];
}
int scrollable_contentBox_getVerticalContentScrollPos(int id, int player) {
return scrollables[id].contentScrollPosY[player];
}
scrollable.active
trigger scrollable_mouseIn_vertical = TriggerCreate("scrollable_mouseIn_vertical_trig");
trigger scrollable_mouseOut_vertical = TriggerCreate("scrollable_mouseOut_vertical_trig");
trigger scrollable_mouseIn_horizontal = TriggerCreate("scrollable_mouseIn_horizontal_trig");
trigger scrollable_mouseOut_horizontal = TriggerCreate("scrollable_mouseOut_horizontal_trig");
trigger scrollable_mouseDown = TriggerCreate("scrollable_mouseDown_trig");
trigger scrollable_mouseUp = TriggerCreate("scrollable_mouseUp_trig");
trigger scrollable_mouseMoved = TriggerCreate("scrollable_mouseMoved_trig");
scrollable.structure
void dummyFunc(int newX, int newY);
struct scrollable{
//Content Box
bool cB;
playergroup cBOwners;
bool[16] cBVisible;
bool[16] cBBackgroundImageVisible;
bool[16] cBBorderImageVisible;
int[16][4] cBBorderSize;
//internal (Dialog Control = DC)
int cBDCBackgroundImage;
int cBDCBorderImage;
int cBDCContentBox;
int cBDCContentMover;
int cBDCContentMoverTop;
int cBDCContentMoverLeft;
//Vertical Slider
bool vS;
playergroup vSOwners;
bool[16] vSVisible;
bool[16] vSBackgroundImageVisible;
bool[16] vSBorderImageVisible;
int[16][4] vSBorderSize;
//internal (Dialog Control = DC)
int vSDCBackgroundImage;
int vSDCBorderImage;
int vSDCSlider;
int[4] vSDCSliderMouseOut;
bool[16] vSIn;
bool[16] vSMoving;
//Horizontal Slider
bool hS;
playergroup hSOwners;
bool[16] hSVisible;
bool[16] hSBackgroundImageVisible;
bool[16] hSBorderImageVisible;
int[16][4] hSBorderSize;
//internal (Dialog Control = DC)
int hSDCBackgroundImage;
int hSDCBorderImage;
int hSDCSlider;
int[4] hSDCSliderMouseOut;
bool[16] hSIn;
bool[16] hSMoving;
bool[16] lockX;
bool[16] lockY;
bool[16] forceX;
bool[16] forceY;
int[16] contentBoxWidth;
int[16] contentBoxHeight;
int[16] contentWidth;
int[16] contentHeight;
int[16] contentScrollPosX;
int[16] contentScrollPosY;
int[16] contentScrollPosMaxX;
int[16] contentScrollPosMaxY;
int[16] sliderPosX;
int[16] sliderPosY;
int[16] sliderPosMaxX;
int[16] sliderPosMaxY;
//general
bool[16] visible;
bool[16] disableDragSelect;
bool[16] slideXY;
string identifier;
funcref<dummyFunc>[16] afterScrolling;
//do not modify
int id;
int[16] forceListNext;
int[16] forceListPrevious;
int stackValue;
};
ImportScrollable