00001 #include "gui_button.hpp"
00002
00003 #include "gui_frame.hpp"
00004 #include "gui_fontstring.hpp"
00005 #include "gui_texture.hpp"
00006 #include "gui_out.hpp"
00007
00008 #include <luapp_function.hpp>
00009
00010 namespace gui
00011 {
00012 void button::register_glue(utils::wptr<lua::state> pLua)
00013 {
00014 pLua->reg<lua_button>();
00015 }
00016
00017 lua_button::lua_button(lua_State* pLua) : lua_frame(pLua)
00018 {
00019 pButtonParent_ = dynamic_cast<button*>(pParent_);
00020 if (pParent_ && !pButtonParent_)
00021 throw exception("lua_button", "Dynamic cast failed !");
00022 }
00023
00024 int lua_button::_click(lua_State* pLua)
00025 {
00026 if (!check_parent_())
00027 return 0;
00028
00029 lua::function mFunc("Button:click", pLua);
00030
00031 pButtonParent_->on("Click");
00032
00033 return mFunc.on_return();
00034 }
00035
00036 int lua_button::_disable(lua_State* pLua)
00037 {
00038 if (!check_parent_())
00039 return 0;
00040
00041 lua::function mFunc("Button:disable", pLua);
00042
00043 pButtonParent_->disable();
00044
00045 return mFunc.on_return();
00046 }
00047
00048 int lua_button::_enable(lua_State* pLua)
00049 {
00050 if (!check_parent_())
00051 return 0;
00052
00053 lua::function mFunc("Button:enable", pLua);
00054
00055 pButtonParent_->enable();
00056
00057 return mFunc.on_return();
00058 }
00059
00060 int lua_button::_get_button_state(lua_State* pLua)
00061 {
00062 if (!check_parent_())
00063 return 0;
00064
00065 lua::function mFunc("Button:get_button_state", pLua, 1);
00066
00067 switch (pButtonParent_->get_button_state())
00068 {
00069 case button::STATE_UP : mFunc.push(std::string("NORMAL")); break;
00070 case button::STATE_DOWN : mFunc.push(std::string("PUSHED")); break;
00071 case button::STATE_DISABLED : mFunc.push(std::string("DISABLED")); break;
00072 default : mFunc.push_nil(); break;
00073 }
00074
00075 return mFunc.on_return();
00076 }
00077
00078 int lua_button::_get_disabled_font_object(lua_State* pLua)
00079 {
00080 if (!check_parent_())
00081 return 0;
00082
00083 lua::function mFunc("Button:get_disabled_font_object", pLua, 1);
00084
00085 font_string* pFontString = pButtonParent_->get_disabled_text();
00086 if (pFontString)
00087 {
00088 pFontString->push_on_lua(mFunc.get_state());
00089 mFunc.notify_pushed();
00090 }
00091 else
00092 mFunc.push_nil();
00093
00094 return mFunc.on_return();
00095 }
00096
00097 int lua_button::_get_disabled_text_color(lua_State* pLua)
00098 {
00099 if (!check_parent_())
00100 return 0;
00101
00102 lua::function mFunc("Button:get_disabled_text_color", pLua, 4);
00103
00104 font_string* pFontString = pButtonParent_->get_disabled_text();
00105 if (pFontString)
00106 {
00107 const color& mColor = pFontString->get_text_color();
00108 mFunc.push(mColor.r);
00109 mFunc.push(mColor.g);
00110 mFunc.push(mColor.b);
00111 mFunc.push(mColor.a);
00112 }
00113 else
00114 mFunc.push_nil(4);
00115
00116 return mFunc.on_return();
00117 }
00118
00119 int lua_button::_get_disabled_texture(lua_State* pLua)
00120 {
00121 if (!check_parent_())
00122 return 0;
00123
00124 lua::function mFunc("Button:get_disabled_texture", pLua, 1);
00125
00126 texture* pTexture = pButtonParent_->get_disabled_texture();
00127 if (pTexture)
00128 {
00129 pTexture->push_on_lua(mFunc.get_state());
00130 mFunc.notify_pushed();
00131 }
00132 else
00133 mFunc.push_nil();
00134
00135 return mFunc.on_return();
00136 }
00137
00138 int lua_button::_get_highlight_font_object(lua_State* pLua)
00139 {
00140 if (!check_parent_())
00141 return 0;
00142
00143 lua::function mFunc("Button:get_highlight_font_object", pLua, 1);
00144
00145 font_string* pFontString = pButtonParent_->get_highlight_text();
00146 if (pFontString)
00147 {
00148 pFontString->push_on_lua(mFunc.get_state());
00149 mFunc.notify_pushed();
00150 }
00151 else
00152 mFunc.push_nil();
00153
00154 return mFunc.on_return();
00155 }
00156
00157 int lua_button::_get_highlight_text_color(lua_State* pLua)
00158 {
00159 if (!check_parent_())
00160 return 0;
00161
00162 lua::function mFunc("Button:get_highlight_text_color", pLua, 4);
00163
00164 font_string* pFontString = pButtonParent_->get_highlight_text();
00165 if (pFontString)
00166 {
00167 const color& mColor = pFontString->get_text_color();
00168 mFunc.push(mColor.r);
00169 mFunc.push(mColor.g);
00170 mFunc.push(mColor.b);
00171 mFunc.push(mColor.a);
00172 }
00173 else
00174 mFunc.push_nil(4);
00175
00176 return mFunc.on_return();
00177 }
00178
00179 int lua_button::_get_highlight_texture(lua_State* pLua)
00180 {
00181 if (!check_parent_())
00182 return 0;
00183
00184 lua::function mFunc("Button:get_highlight_texture", pLua, 1);
00185
00186 texture* pTexture = pButtonParent_->get_highlight_texture();
00187 if (pTexture)
00188 {
00189 pTexture->push_on_lua(mFunc.get_state());
00190 mFunc.notify_pushed();
00191 }
00192 else
00193 mFunc.push_nil();
00194
00195 return mFunc.on_return();
00196 }
00197
00198 int lua_button::_get_normal_font_object(lua_State* pLua)
00199 {
00200 if (!check_parent_())
00201 return 0;
00202
00203 lua::function mFunc("Button:get_normal_font_object", pLua, 1);
00204
00205 font_string* pFontString = pButtonParent_->get_normal_text();
00206 if (pFontString)
00207 {
00208 pFontString->push_on_lua(mFunc.get_state());
00209 mFunc.notify_pushed();
00210 }
00211 else
00212 mFunc.push_nil();
00213
00214 return mFunc.on_return();
00215 }
00216
00217 int lua_button::_get_normal_texture(lua_State* pLua)
00218 {
00219 if (!check_parent_())
00220 return 0;
00221
00222 lua::function mFunc("Button:get_normal_texture", pLua, 1);
00223
00224 texture* pTexture = pButtonParent_->get_normal_texture();
00225 if (pTexture)
00226 {
00227 pTexture->push_on_lua(mFunc.get_state());
00228 mFunc.notify_pushed();
00229 }
00230 else
00231 mFunc.push_nil();
00232
00233 return mFunc.on_return();
00234 }
00235
00236 int lua_button::_get_pushed_text_offset(lua_State* pLua)
00237 {
00238 if (!check_parent_())
00239 return 0;
00240
00241 lua::function mFunc("Button:get_pushed_text_offset", pLua, 2);
00242
00243 std::array<int,2> lOffset = pButtonParent_->get_pushed_text_offset();
00244
00245 mFunc.push(lOffset[0]);
00246 mFunc.push(lOffset[1]);
00247
00248 return mFunc.on_return();
00249 }
00250
00251 int lua_button::_get_pushed_texture(lua_State* pLua)
00252 {
00253 if (!check_parent_())
00254 return 0;
00255
00256 lua::function mFunc("Button:get_pushed_texture", pLua, 1);
00257
00258 texture* pTexture = pButtonParent_->get_pushed_texture();
00259 if (pTexture)
00260 {
00261 pTexture->push_on_lua(mFunc.get_state());
00262 mFunc.notify_pushed();
00263 }
00264 else
00265 mFunc.push_nil();
00266
00267 return mFunc.on_return();
00268 }
00269
00270 int lua_button::_get_text(lua_State* pLua)
00271 {
00272 if (!check_parent_())
00273 return 0;
00274
00275 lua::function mFunc("Button:get_text", pLua, 1);
00276
00277 mFunc.push(pButtonParent_->get_text());
00278
00279 return mFunc.on_return();
00280 }
00281
00282 int lua_button::_get_text_height(lua_State* pLua)
00283 {
00284 if (!check_parent_())
00285 return 0;
00286
00287 lua::function mFunc("Button:get_text_height", pLua, 1);
00288
00289 font_string* pCurrentFont = pButtonParent_->get_CurrentFontString();
00290 if (pCurrentFont)
00291 mFunc.push(pCurrentFont->get_string_height());
00292 else
00293 mFunc.push_nil();
00294
00295 return mFunc.on_return();
00296 }
00297
00298 int lua_button::_get_text_width(lua_State* pLua)
00299 {
00300 if (!check_parent_())
00301 return 0;
00302
00303 lua::function mFunc("Button:get_text_width", pLua, 1);
00304
00305 font_string* pCurrentFont = pButtonParent_->get_CurrentFontString();
00306 if (pCurrentFont)
00307 mFunc.push(pCurrentFont->get_string_width());
00308 else
00309 mFunc.push_nil();
00310
00311 return mFunc.on_return();
00312 }
00313
00314 int lua_button::_is_enabled(lua_State* pLua)
00315 {
00316 if (!check_parent_())
00317 return 0;
00318
00319 lua::function mFunc("Button:is_enabled", pLua, 1);
00320
00321 mFunc.push(pButtonParent_->is_enabled());
00322
00323 return mFunc.on_return();
00324 }
00325
00326 int lua_button::_lock_highlight(lua_State* pLua)
00327 {
00328 if (!check_parent_())
00329 return 0;
00330
00331 lua::function mFunc("Button:lock_highlight", pLua);
00332
00333 pButtonParent_->lock_highlight();
00334
00335 return mFunc.on_return();
00336 }
00337
00338 int lua_button::_set_button_state(lua_State* pLua)
00339 {
00340 if (!check_parent_())
00341 return 0;
00342
00343 lua::function mFunc("Button:set_button_state", pLua);
00344 mFunc.add(0, "button state", lua::TYPE_STRING);
00345 if (mFunc.check())
00346 {
00347 std::string sState = mFunc.get(0)->get_string();
00348 if (sState == "NORMAL")
00349 {
00350 pButtonParent_->enable();
00351 pButtonParent_->release();
00352 }
00353 else if (sState == "PUSHED")
00354 {
00355 pButtonParent_->enable();
00356 pButtonParent_->push();
00357 }
00358 else if (sState == "DISABLED")
00359 {
00360 pButtonParent_->disable();
00361 pButtonParent_->release();
00362 }
00363 else
00364 gui::out << gui::warning << mFunc.get_name() << " : Unknown button state : \""+sState+"\"." << std::endl;
00365 }
00366
00367 return mFunc.on_return();
00368 }
00369
00370 int lua_button::_set_disabled_font_object(lua_State* pLua)
00371 {
00372 if (!check_parent_())
00373 return 0;
00374
00375 lua::function mFunc("Button:set_disabled_font_object", pLua);
00376 mFunc.add(0, "font object", lua::TYPE_USERDATA);
00377 if (mFunc.check())
00378 {
00379 lua_font_string* plua_font_string = mFunc.get_state()->get<lua_font_string>();
00380 if (plua_font_string)
00381 {
00382 font_string* pFontString = dynamic_cast<font_string*>(plua_font_string->get_parent());
00383 pButtonParent_->set_disabled_text(pFontString);
00384 }
00385 }
00386
00387 return mFunc.on_return();
00388 }
00389
00390 int lua_button::_set_disabled_text_color(lua_State* pLua)
00391 {
00392 if (!check_parent_())
00393 return 0;
00394
00395 lua::function mFunc("Button:set_disabled_text_color", pLua);
00396 mFunc.add(0, "r", lua::TYPE_NUMBER);
00397 mFunc.add(1, "g", lua::TYPE_NUMBER);
00398 mFunc.add(2, "b", lua::TYPE_NUMBER);
00399 mFunc.add(3, "a", lua::TYPE_NUMBER, true);
00400 if (mFunc.check())
00401 {
00402 font_string* pFontString = pButtonParent_->get_disabled_text();
00403 if (pFontString)
00404 {
00405 if (mFunc.is_provided(3))
00406 {
00407 pFontString->set_text_color(color(
00408 mFunc.get(0)->get_number(),
00409 mFunc.get(1)->get_number(),
00410 mFunc.get(2)->get_number(),
00411 mFunc.get(3)->get_number()
00412 ));
00413 }
00414 else
00415 {
00416 pFontString->set_text_color(color(
00417 mFunc.get(0)->get_number(),
00418 mFunc.get(1)->get_number(),
00419 mFunc.get(2)->get_number()
00420 ));
00421 }
00422 }
00423 }
00424
00425 return mFunc.on_return();
00426 }
00427
00428 int lua_button::_set_disabled_texture(lua_State* pLua)
00429 {
00430 if (!check_parent_())
00431 return 0;
00432
00433 lua::function mFunc("Button:set_disabled_texture", pLua);
00434 mFunc.add(0, "texture", lua::TYPE_USERDATA);
00435 if (mFunc.check())
00436 {
00437 lua_texture* pLuaTexture = mFunc.get_state()->get<lua_texture>();
00438 if (pLuaTexture)
00439 {
00440 texture* pTexture = dynamic_cast<texture*>(pLuaTexture->get_parent());
00441 pButtonParent_->set_disabled_texture(pTexture);
00442 }
00443 }
00444
00445 return mFunc.on_return();
00446 }
00447
00448 int lua_button::_set_highlight_font_object(lua_State* pLua)
00449 {
00450 if (!check_parent_())
00451 return 0;
00452
00453 lua::function mFunc("Button:set_highlight_font_object", pLua);
00454 mFunc.add(0, "font object", lua::TYPE_USERDATA);
00455 if (mFunc.check())
00456 {
00457 lua_font_string* plua_font_string = mFunc.get_state()->get<lua_font_string>();
00458 if (plua_font_string)
00459 {
00460 font_string* pFontString = dynamic_cast<font_string*>(plua_font_string->get_parent());
00461 pButtonParent_->set_highlight_text(pFontString);
00462 }
00463 }
00464
00465 return mFunc.on_return();
00466 }
00467
00468 int lua_button::_set_highlight_text_color(lua_State* pLua)
00469 {
00470 if (!check_parent_())
00471 return 0;
00472
00473 lua::function mFunc("Button:set_highlight_text_color", pLua);
00474 mFunc.add(0, "r", lua::TYPE_NUMBER);
00475 mFunc.add(1, "g", lua::TYPE_NUMBER);
00476 mFunc.add(2, "b", lua::TYPE_NUMBER);
00477 mFunc.add(3, "a", lua::TYPE_NUMBER, true);
00478 if (mFunc.check())
00479 {
00480 font_string* pFontString = pButtonParent_->get_highlight_text();
00481 if (pFontString)
00482 {
00483 if (mFunc.is_provided(3))
00484 {
00485 pFontString->set_text_color(color(
00486 mFunc.get(0)->get_number(),
00487 mFunc.get(1)->get_number(),
00488 mFunc.get(2)->get_number(),
00489 mFunc.get(3)->get_number()
00490 ));
00491 }
00492 else
00493 {
00494 pFontString->set_text_color(color(
00495 mFunc.get(0)->get_number(),
00496 mFunc.get(1)->get_number(),
00497 mFunc.get(2)->get_number()
00498 ));
00499 }
00500 }
00501 }
00502
00503 return mFunc.on_return();
00504 }
00505
00506 int lua_button::_set_highlight_texture(lua_State* pLua)
00507 {
00508 if (!check_parent_())
00509 return 0;
00510
00511 lua::function mFunc("Button:set_highlight_texture", pLua);
00512 mFunc.add(0, "texture", lua::TYPE_USERDATA);
00513 if (mFunc.check())
00514 {
00515 lua_texture* pLuaTexture = mFunc.get_state()->get<lua_texture>();
00516 if (pLuaTexture)
00517 {
00518 texture* pTexture = dynamic_cast<texture*>(pLuaTexture->get_parent());
00519 pButtonParent_->set_highlight_texture(pTexture);
00520 }
00521 }
00522
00523 return mFunc.on_return();
00524 }
00525
00526
00527 int lua_button::_set_normal_font_object(lua_State* pLua)
00528 {
00529 if (!check_parent_())
00530 return 0;
00531
00532 lua::function mFunc("Button:set_normal_font_object", pLua);
00533 mFunc.add(0, "font object", lua::TYPE_USERDATA);
00534 if (mFunc.check())
00535 {
00536 lua_font_string* plua_font_string = mFunc.get_state()->get<lua_font_string>();
00537 if (plua_font_string)
00538 {
00539 font_string* pFontString = dynamic_cast<font_string*>(plua_font_string->get_parent());
00540 pButtonParent_->set_normal_text(pFontString);
00541 }
00542 }
00543
00544 return mFunc.on_return();
00545 }
00546
00547 int lua_button::_set_normal_text_color(lua_State* pLua)
00548 {
00549 if (!check_parent_())
00550 return 0;
00551
00552 lua::function mFunc("Button:set_normal_text_color", pLua);
00553 mFunc.add(0, "r", lua::TYPE_NUMBER);
00554 mFunc.add(1, "g", lua::TYPE_NUMBER);
00555 mFunc.add(2, "b", lua::TYPE_NUMBER);
00556 mFunc.add(3, "a", lua::TYPE_NUMBER, true);
00557 if (mFunc.check())
00558 {
00559 font_string* pFontString = pButtonParent_->get_normal_text();
00560 if (pFontString)
00561 {
00562 if (mFunc.is_provided(3))
00563 {
00564 pFontString->set_text_color(color(
00565 mFunc.get(0)->get_number(),
00566 mFunc.get(1)->get_number(),
00567 mFunc.get(2)->get_number(),
00568 mFunc.get(3)->get_number()
00569 ));
00570 }
00571 else
00572 {
00573 pFontString->set_text_color(color(
00574 mFunc.get(0)->get_number(),
00575 mFunc.get(1)->get_number(),
00576 mFunc.get(2)->get_number()
00577 ));
00578 }
00579 }
00580 }
00581
00582 return mFunc.on_return();
00583 }
00584
00585 int lua_button::_set_normal_texture(lua_State* pLua)
00586 {
00587 if (!check_parent_())
00588 return 0;
00589
00590 lua::function mFunc("Button:set_normal_texture", pLua);
00591 mFunc.add(0, "texture", lua::TYPE_USERDATA);
00592 if (mFunc.check())
00593 {
00594 lua_texture* pLuaTexture = mFunc.get_state()->get<lua_texture>();
00595 if (pLuaTexture)
00596 {
00597 texture* pTexture = dynamic_cast<texture*>(pLuaTexture->get_parent());
00598 pButtonParent_->set_normal_texture(pTexture);
00599 }
00600 }
00601
00602 return mFunc.on_return();
00603 }
00604
00605 int lua_button::_set_pushed_text_offset(lua_State* pLua)
00606 {
00607 if (!check_parent_())
00608 return 0;
00609
00610 lua::function mFunc("Button:set_pushed_text_offset", pLua);
00611 mFunc.add(0, "x offset", lua::TYPE_NUMBER);
00612 mFunc.add(1, "y offset", lua::TYPE_NUMBER);
00613 if (mFunc.check())
00614 {
00615 pButtonParent_->set_pushed_text_offset({{
00616 (int)mFunc.get(0)->get_number(), (int)mFunc.get(1)->get_number()
00617 }});
00618 }
00619
00620 return mFunc.on_return();
00621 }
00622
00623 int lua_button::_set_pushed_texture(lua_State* pLua)
00624 {
00625 if (!check_parent_())
00626 return 0;
00627
00628 lua::function mFunc("Button:set_pushed_texture", pLua);
00629 mFunc.add(0, "texture", lua::TYPE_USERDATA);
00630 if (mFunc.check())
00631 {
00632 lua_texture* pLuaTexture = mFunc.get_state()->get<lua_texture>();
00633 if (pLuaTexture)
00634 {
00635 texture* pTexture = dynamic_cast<texture*>(pLuaTexture->get_parent());
00636 pButtonParent_->set_pushed_texture(pTexture);
00637 }
00638 }
00639
00640 return mFunc.on_return();
00641 }
00642
00643 int lua_button::_set_text(lua_State* pLua)
00644 {
00645 if (!check_parent_())
00646 return 0;
00647
00648 lua::function mFunc("Button:set_text", pLua);
00649 mFunc.add(0, "text", lua::TYPE_STRING);
00650 if (mFunc.check())
00651 pButtonParent_->set_text(mFunc.get(0)->get_string());
00652
00653 return mFunc.on_return();
00654 }
00655
00656 int lua_button::_unlock_highlight(lua_State* pLua)
00657 {
00658 if (!check_parent_())
00659 return 0;
00660
00661 lua::function mFunc("Button:unlock_highlight", pLua);
00662
00663 pButtonParent_->unlock_highlight();
00664
00665 return mFunc.on_return();
00666 }
00667 }
