00001 #include "gui_fontstring.hpp"
00002 #include "gui_layeredregion.hpp"
00003 #include "gui_out.hpp"
00004
00005 #include <luapp_function.hpp>
00006 #include <utils_string.hpp>
00007
00008 namespace gui
00009 {
00010 void font_string::register_glue(utils::wptr<lua::state> pLua)
00011 {
00012 pLua->reg<lua_font_string>();
00013 }
00014
00015 lua_font_string::lua_font_string(lua_State* pLua) : lua_layered_region(pLua)
00016 {
00017 pFontStringParent_ = dynamic_cast<font_string*>(pParent_);
00018 if (pParent_ && !pFontStringParent_)
00019 throw exception("lua_font_string", "Dynamic cast failed !");
00020 }
00021
00022 int lua_font_string::_get_font(lua_State* pLua)
00023 {
00024 if (!check_parent_())
00025 return 0;
00026
00027 lua::function mFunc("FontString:get_font", pLua, 1);
00028
00029 mFunc.push(pFontStringParent_->get_font_name());
00030
00031 return mFunc.on_return();
00032 }
00033
00034 int lua_font_string::_get_justify_h(lua_State* pLua)
00035 {
00036 if (!check_parent_())
00037 return 0;
00038
00039 lua::function mFunc("FontString:get_justify_h", pLua, 1);
00040
00041 text::alignment mAlignment = pFontStringParent_->get_justify_h();
00042 std::string sAligment;
00043
00044 switch (mAlignment)
00045 {
00046 case text::ALIGN_LEFT : sAligment = "LEFT"; break;
00047 case text::ALIGN_CENTER : sAligment = "CENTER"; break;
00048 case text::ALIGN_RIGHT : sAligment = "RIGHT"; break;
00049 }
00050
00051 mFunc.push(sAligment);
00052
00053 return mFunc.on_return();
00054 }
00055
00056 int lua_font_string::_get_justify_v(lua_State* pLua)
00057 {
00058 if (!check_parent_())
00059 return 0;
00060
00061 lua::function mFunc("FontString:get_justify_v", pLua, 1);
00062
00063 text::vertical_alignment mAlignment = pFontStringParent_->get_justify_v();
00064 std::string sAligment;
00065
00066 switch (mAlignment)
00067 {
00068 case text::ALIGN_TOP : sAligment = "TOP"; break;
00069 case text::ALIGN_MIDDLE : sAligment = "MIDDLE"; break;
00070 case text::ALIGN_BOTTOM : sAligment = "BOTTOM"; break;
00071 }
00072
00073 mFunc.push(sAligment);
00074
00075 return mFunc.on_return();
00076 }
00077
00078 int lua_font_string::_get_shadow_color(lua_State* pLua)
00079 {
00080 if (!check_parent_())
00081 return 0;
00082
00083 lua::function mFunc("FontString:get_shadow_color", pLua, 4);
00084
00085 const color& mShadowColor = pFontStringParent_->get_shadow_color();
00086
00087 mFunc.push(mShadowColor.r);
00088 mFunc.push(mShadowColor.g);
00089 mFunc.push(mShadowColor.b);
00090 mFunc.push(mShadowColor.a);
00091
00092 return mFunc.on_return();
00093 }
00094
00095 int lua_font_string::_get_shadow_offset(lua_State* pLua)
00096 {
00097 if (!check_parent_())
00098 return 0;
00099
00100 lua::function mFunc("FontString:get_shadow_offset", pLua, 2);
00101
00102 mFunc.push(pFontStringParent_->get_shadow_x_offset());
00103 mFunc.push(pFontStringParent_->get_shadow_y_offset());
00104
00105 return mFunc.on_return();
00106 }
00107
00108 int lua_font_string::_get_spacing(lua_State* pLua)
00109 {
00110 if (!check_parent_())
00111 return 0;
00112
00113 lua::function mFunc("FontString:get_spacing", pLua, 1);
00114
00115 mFunc.push(pFontStringParent_->get_spacing());
00116
00117 return mFunc.on_return();
00118 }
00119
00120 int lua_font_string::_get_text_color(lua_State* pLua)
00121 {
00122 if (!check_parent_())
00123 return 0;
00124
00125 lua::function mFunc("FontString:get_text_color", pLua, 4);
00126
00127 const color& mTextColor = pFontStringParent_->get_text_color();
00128
00129 mFunc.push(mTextColor.r);
00130 mFunc.push(mTextColor.g);
00131 mFunc.push(mTextColor.b);
00132 mFunc.push(mTextColor.a);
00133
00134 return mFunc.on_return();
00135 }
00136
00137 int lua_font_string::_set_font(lua_State* pLua)
00138 {
00139 if (!check_parent_())
00140 return 0;
00141
00142 lua::function mFunc("FontString:set_font", pLua);
00143 mFunc.add(0, "file", lua::TYPE_STRING);
00144 mFunc.add(1, "height", lua::TYPE_NUMBER);
00145 mFunc.add(3, "flags", lua::TYPE_STRING, true);
00146
00147 if (mFunc.check())
00148 {
00149 pFontStringParent_->set_font(mFunc.get(0)->get_string(), mFunc.get(1)->get_number());
00150 if (mFunc.is_provided(2))
00151 {
00152 std::string sFlags = mFunc.get(2)->get_string();
00153 if (sFlags.find("OUTLINE") || sFlags.find("THICKOUTLINE"))
00154 pFontStringParent_->set_outlined(true);
00155 else if (sFlags.empty())
00156 pFontStringParent_->set_outlined(false);
00157 else
00158 {
00159 gui::out << gui::warning << mFunc.get_name() << " : "
00160 << "Unknown flag list : \"" << sFlags <<"\"." << std::endl;
00161 }
00162 }
00163 else
00164 pFontStringParent_->set_outlined(false);
00165 }
00166
00167 return mFunc.on_return();
00168 }
00169
00170 int lua_font_string::_set_justify_h(lua_State* pLua)
00171 {
00172 if (!check_parent_())
00173 return 0;
00174
00175 lua::function mFunc("FontString:set_justify_h", pLua);
00176 mFunc.add(0, "justify horizontal", lua::TYPE_STRING);
00177
00178 if (mFunc.check())
00179 {
00180 std::string sJustifyH = mFunc.get(0)->get_string();
00181 if (sJustifyH == "LEFT")
00182 pFontStringParent_->set_justify_h(text::ALIGN_LEFT);
00183 else if (sJustifyH == "CENTER")
00184 pFontStringParent_->set_justify_h(text::ALIGN_CENTER);
00185 else if (sJustifyH == "RIGHT")
00186 pFontStringParent_->set_justify_h(text::ALIGN_RIGHT);
00187 else
00188 {
00189 gui::out << gui::warning << mFunc.get_name() << " : "
00190 << "Unknown justify behavior : \"" << sJustifyH << "\"." << std::endl;
00191 }
00192 }
00193
00194 return mFunc.on_return();
00195 }
00196
00197 int lua_font_string::_set_justify_v(lua_State* pLua)
00198 {
00199 if (!check_parent_())
00200 return 0;
00201
00202 lua::function mFunc("FontString:set_justify_v", pLua);
00203 mFunc.add(0, "justify vertical", lua::TYPE_STRING);
00204
00205 if (mFunc.check())
00206 {
00207 std::string sJustifyV = mFunc.get(0)->get_string();
00208 if (sJustifyV == "TOP")
00209 pFontStringParent_->set_justify_v(text::ALIGN_TOP);
00210 else if (sJustifyV == "MIDDLE")
00211 pFontStringParent_->set_justify_v(text::ALIGN_MIDDLE);
00212 else if (sJustifyV == "BOTTOM")
00213 pFontStringParent_->set_justify_v(text::ALIGN_BOTTOM);
00214 else
00215 {
00216 gui::out << gui::warning << mFunc.get_name() << " : "
00217 << "Unknown justify behavior : \"" << sJustifyV << "\"." << std::endl;
00218 }
00219 }
00220
00221 return mFunc.on_return();
00222 }
00223
00224 int lua_font_string::_set_shadow_color(lua_State* pLua)
00225 {
00226 if (!check_parent_())
00227 return 0;
00228
00229 lua::function mFunc("FontString:set_shadow_color", pLua);
00230 mFunc.add(0, "red", lua::TYPE_NUMBER);
00231 mFunc.add(1, "green", lua::TYPE_NUMBER);
00232 mFunc.add(2, "blue", lua::TYPE_NUMBER);
00233 mFunc.add(3, "alpha", lua::TYPE_NUMBER, true);
00234
00235 if (mFunc.check())
00236 {
00237 color mColor;
00238 if (mFunc.is_provided(3))
00239 {
00240 mColor = color(
00241 mFunc.get(0)->get_number(),
00242 mFunc.get(1)->get_number(),
00243 mFunc.get(2)->get_number(),
00244 mFunc.get(3)->get_number()
00245 );
00246 }
00247 else
00248 {
00249 mColor = color(
00250 mFunc.get(0)->get_number(),
00251 mFunc.get(1)->get_number(),
00252 mFunc.get(2)->get_number()
00253 );
00254 }
00255
00256 pFontStringParent_->set_shadow_color(mColor);
00257 }
00258
00259 return mFunc.on_return();
00260 }
00261
00262 int lua_font_string::_set_shadow_offset(lua_State* pLua)
00263 {
00264 if (!check_parent_())
00265 return 0;
00266
00267 lua::function mFunc("FontString:set_shadow_offset", pLua);
00268 mFunc.add(0, "x offset", lua::TYPE_NUMBER);
00269 mFunc.add(1, "y offset", lua::TYPE_NUMBER);
00270
00271 if (mFunc.check())
00272 {
00273 pFontStringParent_->set_shadow_offsets(
00274 int(mFunc.get(0)->get_number()),
00275 int(mFunc.get(1)->get_number())
00276 );
00277 }
00278
00279 return mFunc.on_return();
00280 }
00281
00282 int lua_font_string::_set_spacing(lua_State* pLua)
00283 {
00284 if (!check_parent_())
00285 return 0;
00286
00287 lua::function mFunc("FontString:set_spacing", pLua);
00288 mFunc.add(0, "spacing", lua::TYPE_NUMBER);
00289
00290 if (mFunc.check())
00291 {
00292 pFontStringParent_->set_spacing(mFunc.get(0)->get_number());
00293 }
00294
00295 return mFunc.on_return();
00296 }
00297
00298 int lua_font_string::_set_text_color(lua_State* pLua)
00299 {
00300 if (!check_parent_())
00301 return 0;
00302
00303 lua::function mFunc("FontString:set_text_color", pLua);
00304 mFunc.add(0, "red", lua::TYPE_NUMBER);
00305 mFunc.add(1, "green", lua::TYPE_NUMBER);
00306 mFunc.add(2, "blue", lua::TYPE_NUMBER);
00307 mFunc.add(3, "alpha", lua::TYPE_NUMBER, true);
00308
00309 if (mFunc.check())
00310 {
00311 color mColor;
00312 if (mFunc.is_provided(3))
00313 {
00314 mColor = color(
00315 mFunc.get(0)->get_number(),
00316 mFunc.get(1)->get_number(),
00317 mFunc.get(2)->get_number(),
00318 mFunc.get(3)->get_number()
00319 );
00320 }
00321 else
00322 {
00323 mColor = color(
00324 mFunc.get(0)->get_number(),
00325 mFunc.get(1)->get_number(),
00326 mFunc.get(2)->get_number()
00327 );
00328 }
00329
00330 pFontStringParent_->set_text_color(mColor);
00331 }
00332
00333 return mFunc.on_return();
00334 }
00335
00336 int lua_font_string::_can_non_space_wrap(lua_State* pLua)
00337 {
00338 if (!check_parent_())
00339 return 0;
00340
00341 lua::function mFunc("FontString:can_non_space_wrap", pLua, 1);
00342
00343 mFunc.push(pFontStringParent_->can_non_space_wrap());
00344
00345 return mFunc.on_return();
00346 }
00347
00348 int lua_font_string::_can_word_wrap(lua_State* pLua)
00349 {
00350 if (!check_parent_())
00351 return 0;
00352
00353 lua::function mFunc("FontString:can_word_wrap", pLua, 1);
00354
00355 mFunc.push(pFontStringParent_->can_word_wrap());
00356
00357 return mFunc.on_return();
00358 }
00359
00360 int lua_font_string::_enable_formatting(lua_State* pLua)
00361 {
00362 if (!check_parent_())
00363 return 0;
00364
00365 lua::function mFunc("FontString:enable_formatting", pLua);
00366 mFunc.add(0, "formatting", lua::TYPE_BOOLEAN);
00367
00368 if (mFunc.check())
00369 {
00370 pFontStringParent_->enable_formatting(mFunc.get(0)->get_bool());
00371 }
00372
00373 return mFunc.on_return();
00374 }
00375
00376 int lua_font_string::_get_string_height(lua_State* pLua)
00377 {
00378 if (!check_parent_())
00379 return 0;
00380
00381 lua::function mFunc("FontString:get_string_height", pLua, 1);
00382
00383 mFunc.push(pFontStringParent_->get_string_height());
00384
00385 return mFunc.on_return();
00386 }
00387
00388 int lua_font_string::_get_string_width(lua_State* pLua)
00389 {
00390 if (!check_parent_())
00391 return 0;
00392
00393 lua::function mFunc("FontString:get_string_width", pLua, 1);
00394
00395 mFunc.push(pFontStringParent_->get_string_width());
00396
00397 return mFunc.on_return();
00398 }
00399
00400 int lua_font_string::_get_text(lua_State* pLua)
00401 {
00402 if (!check_parent_())
00403 return 0;
00404
00405 lua::function mFunc("FontString:get_text", pLua, 1);
00406
00407 mFunc.push(pFontStringParent_->get_text());
00408
00409 return mFunc.on_return();
00410 }
00411
00412 int lua_font_string::_is_formatting_enabled(lua_State* pLua)
00413 {
00414 if (!check_parent_())
00415 return 0;
00416
00417 lua::function mFunc("FontString:is_formatting_enabled", pLua, 1);
00418
00419 mFunc.push(pFontStringParent_->is_formatting_enabled());
00420
00421 return mFunc.on_return();
00422 }
00423
00424 int lua_font_string::_set_non_space_wrap(lua_State* pLua)
00425 {
00426 if (!check_parent_())
00427 return 0;
00428
00429 lua::function mFunc("FontString:set_non_space_wrap", pLua);
00430 mFunc.add(0, "can non space wrap", lua::TYPE_BOOLEAN);
00431
00432 if (mFunc.check())
00433 {
00434 pFontStringParent_->set_non_space_wrap(mFunc.get(0)->get_bool());
00435 }
00436
00437 return mFunc.on_return();
00438 }
00439
00440 int lua_font_string::_set_word_wrap(lua_State* pLua)
00441 {
00442 if (!check_parent_())
00443 return 0;
00444
00445 lua::function mFunc("FontString:set_word_wrap", pLua);
00446 mFunc.add(0, "can word wrap", lua::TYPE_BOOLEAN);
00447 mFunc.add(1, "add ellipsis", lua::TYPE_BOOLEAN, true);
00448
00449 if (mFunc.check())
00450 {
00451 bool bEllipsis = true;
00452 if (mFunc.is_provided(1))
00453 bEllipsis = mFunc.get(1)->get_bool();
00454
00455 pFontStringParent_->set_word_wrap(mFunc.get(0)->get_bool(), bEllipsis);
00456 }
00457
00458 return mFunc.on_return();
00459 }
00460
00461 int lua_font_string::_set_text(lua_State* pLua)
00462 {
00463 if (!check_parent_())
00464 return 0;
00465
00466 lua::function mFunc("FontString:set_text", pLua);
00467 mFunc.add(0, "text", lua::TYPE_STRING);
00468 mFunc.add(0, "number", lua::TYPE_NUMBER);
00469 mFunc.add(0, "bool", lua::TYPE_BOOLEAN);
00470
00471 if (mFunc.check())
00472 {
00473 std::string sText;
00474 if (mFunc.get(0)->get_type() == lua::TYPE_STRING)
00475 sText = mFunc.get(0)->get_string();
00476 else if (mFunc.get(0)->get_type() == lua::TYPE_NUMBER)
00477 sText = utils::to_string(mFunc.get(0)->get_number());
00478 else if (mFunc.get(0)->get_type() == lua::TYPE_BOOLEAN)
00479 sText = utils::to_string(mFunc.get(0)->get_bool());
00480
00481 pFontStringParent_->set_text(sText);
00482 }
00483
00484 return mFunc.on_return();
00485 }
00486 }
