aboutsummaryrefslogtreecommitdiff
path: root/builtin/fstk/buttonbar.lua
blob: 465588324a4ae8885ed6e3b085ac95c09552325c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
--Minetest
--Copyright (C) 2014 sapier
--
--This program is free software; you can redistribute it and/or modify
--it under the terms of the GNU Lesser General Public License as published by
--the Free Software Foundation; either version 2.1 of the License, or
--(at your option) any later version.
--
--This program is distributed in the hope that it will be useful,
--but WITHOUT ANY WARRANTY; without even the implied warranty of
--MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--GNU Lesser General Public License for more details.
--
--You should have received a copy of the GNU Lesser General Public License along
--with this program; if not, write to the Free Software Foundation, Inc.,
--51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.


local function buttonbar_formspec(self)

	if self.hidden then
		return ""
	end

	local formspec = string.format("box[%f,%f;%f,%f;%s]",
			self.pos.x,self.pos.y ,self.size.x,self.size.y,self.bgcolor)

	for i=self.startbutton,#self.buttons,1 do
		local btn_name = self.buttons[i].name
		local btn_pos = {}

		if self.orientation == "horizontal" then
			btn_pos.x = self.pos.x + --base pos
			(i - self.startbutton) * self.btn_size +       --button offset
			self.btn_initial_offset
		else
			btn_pos.x = self.pos.x + (self.btn_size * 0.05)
		end

		if self.orientation == "vertical" then
			btn_pos.y = self.pos.y + --base pos
			(i - self.startbutton) * self.btn_size +       --button offset
			self.btn_initial_offset
		else
			btn_pos.y = self.pos.y + (self.btn_size * 0.05)
		end

		if (self.orientation == "vertical" and
			(btn_pos.y + self.btn_size <= self.pos.y + self.size.y)) or
			(self.orientation == "horizontal" and
			(btn_pos.x + self.btn_size <= self.pos.x + self.size.x)) then

		local borders="true"

		if self.buttons[i].image ~= nil then
			borders="false"
		end

		formspec = formspec ..
			string.format("image_button[%f,%f;%f,%f;%s;%s;%s;true;%s]tooltip[%s;%s]",
					btn_pos.x, btn_pos.y, self.btn_size, self.btn_size,
					self.buttons[i].image, btn_name, self.buttons[i].caption,
					borders, btn_name, self.buttons[i].tooltip)
		else
			--print("end of displayable buttons: orientation: " .. self.orientation)
			--print( "button_end: " .. (btn_pos.y + self.btn_size - (self.btn_size * 0.05)))
			--print( "bar_end: " .. (self.pos.x + self.size.x))
			break
		end
	end

	if (self.have_move_buttons) then
		local btn_dec_pos = {}
		btn_dec_pos.x = self.pos.x + (self.btn_size * 0.05)
		btn_dec_pos.y = self.pos.y + (self.btn_size * 0.05)
		local btn_inc_pos = {}
		local btn_size = {}

		if self.orientation == "horizontal" then
			btn_size.x = 0.5
			btn_size.y = self.btn_size
			btn_inc_pos.x = self.pos.x + self.size.x - 0.5
			btn_inc_pos.y = self.pos.y + (self.btn_size * 0.05)
		else
			btn_size.x = self.btn_size
			btn_size.y = 0.5
			btn_inc_pos.x = self.pos.x + (self.btn_size * 0.05)
			btn_inc_pos.y = self.pos.y + self.size.y - 0.5
		end

		local text_dec = "<"
		local text_inc = ">"
		if self.orientation == "vertical" then
			text_dec = "^"
			text_inc = "v"
		end

		formspec = formspec ..
			string.format("image_button[%f,%f;%f,%f;;btnbar_dec_%s;%s;true;true]",
					btn_dec_pos.x, btn_dec_pos.y, btn_size.x, btn_size.y,
					self.name, text_dec)

		formspec = formspec ..
			string.format("image_button[%f,%f;%f,%f;;btnbar_inc_%s;%s;true;true]",
					btn_inc_pos.x, btn_inc_pos.y, btn_size.x, btn_size.y,
					 self.name, text_inc)
	end

	return formspec
end

local function buttonbar_buttonhandler(self, fields)

	if fields["btnbar_inc_" .. self.name] ~= nil and
		self.startbutton < #self.buttons then

		self.startbutton = self.startbutton + 1
		return true
	end

	if fields["btnbar_dec_" .. self.name] ~= nil and self.startbutton > 1 then
		self.startbutton = self.startbutton - 1
		return true
	end

	for i=1,#self.buttons,1 do
		if fields[self.buttons[i].name] ~= nil then
			return self.userbuttonhandler(fields)
		end
	end
end

local buttonbar_metatable = {
	handle_buttons = buttonbar_buttonhandler,
	handle_events  = function(self, event) end,
	get_formspec   = buttonbar_formspec,

	hide = function(self) self.hidden = true end,
	show = function(self) self.hidden = false end,

	delete = function(self) ui.delete(self) end,

	add_button = function(self, name, caption, image, tooltip)
			if caption == nil then caption = "" end
			if image == nil then image = "" end
			if tooltip == nil then tooltip = "" end

			self.buttons[#self.buttons + 1] = {
				name = name,
				caption = caption,
				image = image,
				tooltip = tooltip
			}
			if self.orientation == "horizontal" then
				if ( (self.btn_size * #self.buttons) + (self.btn_size * 0.05 *2)
					> self.size.x ) then

					self.btn_initial_offset = self.btn_size * 0.05 + 0.5
					self.have_move_buttons = true
				end
			else
				if ((self.btn_size * #self.buttons) + (self.btn_size * 0.05 *2)
					> self.size.y ) then

					self.btn_initial_offset = self.btn_size * 0.05 + 0.5
					self.have_move_buttons = true
				end
			end
		end,

	set_bgparams = function(self, bgcolor)
			if (type(bgcolor) == "string") then
				self.bgcolor = bgcolor
			end
		end,
}

buttonbar_metatable.__index = buttonbar_metatable

function buttonbar_create(name, cbf_buttonhandler, pos, orientation, size)
	assert(name ~= nil)
	assert(cbf_buttonhandler ~= nil)
	assert(orientation == "vertical" or orientation == "horizontal")
	assert(pos ~= nil and type(pos) == "table")
	assert(size ~= nil and type(size) == "table")

	local self = {}
	self.name = name
	self.type = "addon"
	self.bgcolor = "#000000"
	self.pos = pos
	self.size = size
	self.orientation = orientation
	self.startbutton = 1
	self.have_move_buttons = false
	self.hidden = false

	if self.orientation == "horizontal" then
			self.btn_size = self.size.y
	else
			self.btn_size = self.size.x
	end

	if (self.btn_initial_offset == nil) then
		self.btn_initial_offset = self.btn_size * 0.05
	end

	self.userbuttonhandler = cbf_buttonhandler
	self.buttons = {}

	setmetatable(self,buttonbar_metatable)

	ui.add(self)
	return self
end
an class="hl kwd">Pressed(false), UseAlphaChannel(false), DrawBorder(true), ScaleImage(false), TSrc(tsrc) { setNotClipped(noclip); // This element can be tabbed. setTabStop(true); setTabOrder(-1); // PATCH for (size_t i = 0; i < 4; i++) { Colors[i] = Environment->getSkin()->getColor((EGUI_DEFAULT_COLOR)i); } StaticText = gui::StaticText::add(Environment, Text.c_str(), core::rect<s32>(0,0,rectangle.getWidth(),rectangle.getHeight()), false, false, this, id); StaticText->setTextAlignment(EGUIA_CENTER, EGUIA_CENTER); // END PATCH } //! destructor GUIButton::~GUIButton() { if (OverrideFont) OverrideFont->drop(); if (SpriteBank) SpriteBank->drop(); } //! Sets if the images should be scaled to fit the button void GUIButton::setScaleImage(bool scaleImage) { ScaleImage = scaleImage; } //! Returns whether the button scale the used images bool GUIButton::isScalingImage() const { return ScaleImage; } //! Sets if the button should use the skin to draw its border void GUIButton::setDrawBorder(bool border) { DrawBorder = border; } void GUIButton::setSpriteBank(IGUISpriteBank* sprites) { if (sprites) sprites->grab(); if (SpriteBank) SpriteBank->drop(); SpriteBank = sprites; } void GUIButton::setSprite(EGUI_BUTTON_STATE state, s32 index, video::SColor color, bool loop, bool scale) { ButtonSprites[(u32)state].Index = index; ButtonSprites[(u32)state].Color = color; ButtonSprites[(u32)state].Loop = loop; ButtonSprites[(u32)state].Scale = scale; } //! Get the sprite-index for the given state or -1 when no sprite is set s32 GUIButton::getSpriteIndex(EGUI_BUTTON_STATE state) const { return ButtonSprites[(u32)state].Index; } //! Get the sprite color for the given state. Color is only used when a sprite is set. video::SColor GUIButton::getSpriteColor(EGUI_BUTTON_STATE state) const { return ButtonSprites[(u32)state].Color; } //! Returns if the sprite in the given state does loop bool GUIButton::getSpriteLoop(EGUI_BUTTON_STATE state) const { return ButtonSprites[(u32)state].Loop; } //! Returns if the sprite in the given state is scaled bool GUIButton::getSpriteScale(EGUI_BUTTON_STATE state) const { return ButtonSprites[(u32)state].Scale; } //! called if an event happened. bool GUIButton::OnEvent(const SEvent& event) { if (!isEnabled()) return IGUIElement::OnEvent(event); switch(event.EventType) { case EET_KEY_INPUT_EVENT: if (event.KeyInput.PressedDown && (event.KeyInput.Key == KEY_RETURN || event.KeyInput.Key == KEY_SPACE)) { if (!IsPushButton) setPressed(true); else setPressed(!Pressed); return true; } if (Pressed && !IsPushButton && event.KeyInput.PressedDown && event.KeyInput.Key == KEY_ESCAPE) { setPressed(false); return true; } else if (!event.KeyInput.PressedDown && Pressed && (event.KeyInput.Key == KEY_RETURN || event.KeyInput.Key == KEY_SPACE)) { if (!IsPushButton) setPressed(false); if (Parent) { ClickShiftState = event.KeyInput.Shift; ClickControlState = event.KeyInput.Control; SEvent newEvent; newEvent.EventType = EET_GUI_EVENT; newEvent.GUIEvent.Caller = this; newEvent.GUIEvent.Element = 0; newEvent.GUIEvent.EventType = EGET_BUTTON_CLICKED; Parent->OnEvent(newEvent); } return true; } break; case EET_GUI_EVENT: if (event.GUIEvent.Caller == this) { if (event.GUIEvent.EventType == EGET_ELEMENT_FOCUS_LOST) { if (!IsPushButton) setPressed(false); FocusTime = (u32)porting::getTimeMs(); } else if (event.GUIEvent.EventType == EGET_ELEMENT_FOCUSED) { FocusTime = (u32)porting::getTimeMs(); } else if (event.GUIEvent.EventType == EGET_ELEMENT_HOVERED || event.GUIEvent.EventType == EGET_ELEMENT_LEFT) { HoverTime = (u32)porting::getTimeMs(); } } break; case EET_MOUSE_INPUT_EVENT: if (event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) { // Sometimes formspec elements can receive mouse events when the // mouse is outside of the formspec. Thus, we test the position here. if ( !IsPushButton && AbsoluteClippingRect.isPointInside( core::position2d<s32>(event.MouseInput.X, event.MouseInput.Y ))) { setPressed(true); } return true; } else if (event.MouseInput.Event == EMIE_LMOUSE_LEFT_UP) { bool wasPressed = Pressed; if ( !AbsoluteClippingRect.isPointInside( core::position2d<s32>(event.MouseInput.X, event.MouseInput.Y ) ) ) { if (!IsPushButton) setPressed(false); return true; } if (!IsPushButton) setPressed(false); else { setPressed(!Pressed); } if ((!IsPushButton && wasPressed && Parent) || (IsPushButton && wasPressed != Pressed)) { ClickShiftState = event.MouseInput.Shift; ClickControlState = event.MouseInput.Control; SEvent newEvent; newEvent.EventType = EET_GUI_EVENT; newEvent.GUIEvent.Caller = this; newEvent.GUIEvent.Element = 0; newEvent.GUIEvent.EventType = EGET_BUTTON_CLICKED; Parent->OnEvent(newEvent); } return true; } break; default: break; } return Parent ? Parent->OnEvent(event) : false; } //! draws the element and its children void GUIButton::draw() { if (!IsVisible) return; // PATCH // Track hovered state, if it has changed then we need to update the style. bool hovered = isHovered(); if (hovered != WasHovered) { WasHovered = hovered; setFromState(); } GUISkin* skin = dynamic_cast<GUISkin*>(Environment->getSkin()); video::IVideoDriver* driver = Environment->getVideoDriver(); // END PATCH if (DrawBorder) { if (!Pressed) { // PATCH skin->drawColored3DButtonPaneStandard(this, AbsoluteRect, &AbsoluteClippingRect, Colors); // END PATCH } else { // PATCH skin->drawColored3DButtonPanePressed(this, AbsoluteRect, &AbsoluteClippingRect, Colors); // END PATCH } } const core::position2di buttonCenter(AbsoluteRect.getCenter()); // PATCH // The image changes based on the state, so we use the default every time. EGUI_BUTTON_IMAGE_STATE imageState = EGBIS_IMAGE_UP; // END PATCH if ( ButtonImages[(u32)imageState].Texture ) { core::position2d<s32> pos(buttonCenter); core::rect<s32> sourceRect(ButtonImages[(u32)imageState].SourceRect); if ( sourceRect.getWidth() == 0 && sourceRect.getHeight() == 0 ) sourceRect = core::rect<s32>(core::position2di(0,0), ButtonImages[(u32)imageState].Texture->getOriginalSize()); pos.X -= sourceRect.getWidth() / 2; pos.Y -= sourceRect.getHeight() / 2; if ( Pressed ) { // Create a pressed-down effect by moving the image when it looks identical to the unpressed state image EGUI_BUTTON_IMAGE_STATE unpressedState = getImageState(false); if ( unpressedState == imageState || ButtonImages[(u32)imageState] == ButtonImages[(u32)unpressedState] ) { pos.X += skin->getSize(EGDS_BUTTON_PRESSED_IMAGE_OFFSET_X); pos.Y += skin->getSize(EGDS_BUTTON_PRESSED_IMAGE_OFFSET_Y); } } // PATCH video::ITexture* texture = ButtonImages[(u32)imageState].Texture; video::SColor image_colors[] = { BgColor, BgColor, BgColor, BgColor }; if (BgMiddle.getArea() == 0) { driver->draw2DImage(texture, ScaleImage? AbsoluteRect : core::rect<s32>(pos, sourceRect.getSize()), sourceRect, &AbsoluteClippingRect, image_colors, UseAlphaChannel); } else { core::rect<s32> middle = BgMiddle; // `-x` is interpreted as `w - x` if (middle.LowerRightCorner.X < 0) middle.LowerRightCorner.X += texture->getOriginalSize().Width; if (middle.LowerRightCorner.Y < 0) middle.LowerRightCorner.Y += texture->getOriginalSize().Height; draw2DImage9Slice(driver, texture, ScaleImage ? AbsoluteRect : core::rect<s32>(pos, sourceRect.getSize()), middle, &AbsoluteClippingRect, image_colors); } // END PATCH } if (SpriteBank) { core::position2di pos(buttonCenter); if (isEnabled()) { // pressed / unpressed animation EGUI_BUTTON_STATE state = Pressed ? EGBS_BUTTON_DOWN : EGBS_BUTTON_UP; drawSprite(state, ClickTime, pos); // focused / unfocused animation state = Environment->hasFocus(this) ? EGBS_BUTTON_FOCUSED : EGBS_BUTTON_NOT_FOCUSED; drawSprite(state, FocusTime, pos); // mouse over / off animation state = isHovered() ? EGBS_BUTTON_MOUSE_OVER : EGBS_BUTTON_MOUSE_OFF; drawSprite(state, HoverTime, pos); } else { // draw disabled // drawSprite(EGBS_BUTTON_DISABLED, 0, pos); } } IGUIElement::draw(); } void GUIButton::drawSprite(EGUI_BUTTON_STATE state, u32 startTime, const core::position2di& center) { u32 stateIdx = (u32)state; if (ButtonSprites[stateIdx].Index != -1) { if ( ButtonSprites[stateIdx].Scale ) { const video::SColor colors[] = {ButtonSprites[stateIdx].Color,ButtonSprites[stateIdx].Color,ButtonSprites[stateIdx].Color,ButtonSprites[stateIdx].Color}; SpriteBank->draw2DSprite(ButtonSprites[stateIdx].Index, AbsoluteRect.UpperLeftCorner, &AbsoluteClippingRect, colors[0], // FIXME: remove [0] porting::getTimeMs()-startTime, ButtonSprites[stateIdx].Loop); } else { SpriteBank->draw2DSprite(ButtonSprites[stateIdx].Index, center, &AbsoluteClippingRect, ButtonSprites[stateIdx].Color, startTime, porting::getTimeMs(), ButtonSprites[stateIdx].Loop, true); } } } EGUI_BUTTON_IMAGE_STATE GUIButton::getImageState(bool pressed) const { // PATCH return getImageState(pressed, ButtonImages); // END PATCH } EGUI_BUTTON_IMAGE_STATE GUIButton::getImageState(bool pressed, const ButtonImage* images) const { // figure state we should have EGUI_BUTTON_IMAGE_STATE state = EGBIS_IMAGE_DISABLED; bool focused = Environment->hasFocus((IGUIElement*)this); bool mouseOver = isHovered(); if (isEnabled()) { if ( pressed ) { if ( focused && mouseOver ) state = EGBIS_IMAGE_DOWN_FOCUSED_MOUSEOVER; else if ( focused ) state = EGBIS_IMAGE_DOWN_FOCUSED; else if ( mouseOver ) state = EGBIS_IMAGE_DOWN_MOUSEOVER; else state = EGBIS_IMAGE_DOWN; } else // !pressed { if ( focused && mouseOver ) state = EGBIS_IMAGE_UP_FOCUSED_MOUSEOVER; else if ( focused ) state = EGBIS_IMAGE_UP_FOCUSED; else if ( mouseOver ) state = EGBIS_IMAGE_UP_MOUSEOVER; else state = EGBIS_IMAGE_UP; } } // find a compatible state that has images while ( state != EGBIS_IMAGE_UP && !images[(u32)state].Texture ) { // PATCH switch ( state ) { case EGBIS_IMAGE_UP_FOCUSED: state = EGBIS_IMAGE_UP; break; case EGBIS_IMAGE_UP_FOCUSED_MOUSEOVER: state = EGBIS_IMAGE_UP_FOCUSED; break; case EGBIS_IMAGE_DOWN_MOUSEOVER: state = EGBIS_IMAGE_DOWN; break; case EGBIS_IMAGE_DOWN_FOCUSED: state = EGBIS_IMAGE_DOWN; break; case EGBIS_IMAGE_DOWN_FOCUSED_MOUSEOVER: state = EGBIS_IMAGE_DOWN_FOCUSED; break; case EGBIS_IMAGE_DISABLED: if ( pressed ) state = EGBIS_IMAGE_DOWN; else state = EGBIS_IMAGE_UP; break; default: state = EGBIS_IMAGE_UP; } // END PATCH } return state; } //! sets another skin independent font. if this is set to zero, the button uses the font of the skin. void GUIButton::setOverrideFont(IGUIFont* font) { if (OverrideFont == font) return; if (OverrideFont) OverrideFont->drop(); OverrideFont = font; if (OverrideFont) OverrideFont->grab(); StaticText->setOverrideFont(font); } //! Gets the override font (if any) IGUIFont * GUIButton::getOverrideFont() const { return OverrideFont; } //! Get the font which is used right now for drawing IGUIFont* GUIButton::getActiveFont() const { if ( OverrideFont ) return OverrideFont; IGUISkin* skin = Environment->getSkin(); if (skin) return skin->getFont(EGDF_BUTTON); return 0; } //! Sets another color for the text. void GUIButton::setOverrideColor(video::SColor color) { OverrideColor = color; OverrideColorEnabled = true; StaticText->setOverrideColor(color); } video::SColor GUIButton::getOverrideColor() const { return OverrideColor; } void GUIButton::enableOverrideColor(bool enable) { OverrideColorEnabled = enable; } bool GUIButton::isOverrideColorEnabled() const { return OverrideColorEnabled; } void GUIButton::setImage(EGUI_BUTTON_IMAGE_STATE state, video::ITexture* image, const core::rect<s32>& sourceRect) { if ( state >= EGBIS_COUNT ) return; if ( image ) image->grab(); u32 stateIdx = (u32)state; if ( ButtonImages[stateIdx].Texture ) ButtonImages[stateIdx].Texture->drop(); ButtonImages[stateIdx].Texture = image; ButtonImages[stateIdx].SourceRect = sourceRect; } // PATCH void GUIButton::setImage(video::ITexture* image) { setImage(gui::EGBIS_IMAGE_UP, image); } void GUIButton::setImage(video::ITexture* image, const core::rect<s32>& pos) { setImage(gui::EGBIS_IMAGE_UP, image, pos); } void GUIButton::setPressedImage(video::ITexture* image) { setImage(gui::EGBIS_IMAGE_DOWN, image); } void GUIButton::setPressedImage(video::ITexture* image, const core::rect<s32>& pos) { setImage(gui::EGBIS_IMAGE_DOWN, image, pos); } //! Sets the text displayed by the button void GUIButton::setText(const wchar_t* text) { StaticText->setText(text); IGUIButton::setText(text); } // END PATCH //! Sets if the button should behave like a push button. Which means it //! can be in two states: Normal or Pressed. With a click on the button, //! the user can change the state of the button. void GUIButton::setIsPushButton(bool isPushButton) { IsPushButton = isPushButton; } //! Returns if the button is currently pressed bool GUIButton::isPressed() const { return Pressed; } // PATCH //! Returns if this element (or one of its direct children) is hovered bool GUIButton::isHovered() const { IGUIElement *hovered = Environment->getHovered(); return hovered == this || (hovered != nullptr && hovered->getParent() == this); } // END PATCH //! Sets the pressed state of the button if this is a pushbutton void GUIButton::setPressed(bool pressed) { if (Pressed != pressed) { ClickTime = porting::getTimeMs(); Pressed = pressed; setFromState(); } } //! Returns whether the button is a push button bool GUIButton::isPushButton() const { return IsPushButton; } //! Sets if the alpha channel should be used for drawing images on the button (default is false) void GUIButton::setUseAlphaChannel(bool useAlphaChannel) { UseAlphaChannel = useAlphaChannel; } //! Returns if the alpha channel should be used for drawing images on the button bool GUIButton::isAlphaChannelUsed() const { return UseAlphaChannel;