src/luaapi/options.cpp

   1 /*
   2   Copyright (c) 2006 Paolo Capriotti <p.capriotti@sns.it>
   3             (c) 2006 Maurizio Monge <maurizio.monge@kdemail.net>
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9 */
  10
  11 #include "options.h"
  12 #include "luaapi/loader.h"
  13
  14 namespace LuaApi {
  15
  16 //BEGIN Wrapper<OptList> -------------------------------------------------------
  17
  18 const char* Wrapper<OptList>::class_name() {
  19   return "OptList";
  20 }
  21
  22 int Wrapper<OptList>::to_string(lua_State* l) {
  23   OptList r = *retrieve(l, 1, AssertOk);
  24   QString s;
  25   for(int i=0;i<r.size();i++)
  26     s += (i==0?"":",")+r[i]->name();
  27   s = "list["+s+"]";
  28   lua_pop(l, 1);
  29   lua_pushstring(l, s.toAscii().constData());
  30   return 1;
  31 }
  32
  33 int Wrapper<OptList>::newindex_event(lua_State* l) {
  34   lua_pop(l,3);
  35   luaL_error(l, "OptList cannot be modified after being constructed!!!");
  36   return 0;
  37 }
  38
  39 int Wrapper<OptList>::index_event(lua_State* l) {
  40   const char *k = lua_tostring(l, -1);
  41   OptList& list = *retrieve(l, -2);
  42   lua_pop(l,2);
  43   for(int i=0; i<list.size();i++) {
  44     if(list[i]->name() == k) {
  45       if(BoolOptPtr p = boost::dynamic_pointer_cast<BoolOpt, BaseOpt>(list[i]))
  46         GenericWrapperByValue<BoolOptPtr>::create(l, p);
  47       else if(IntOptPtr p = boost::dynamic_pointer_cast<IntOpt, BaseOpt>(list[i]))
  48         GenericWrapperByValue<IntOptPtr>::create(l, p);
  49       else if(StringOptPtr p = boost::dynamic_pointer_cast<StringOpt, BaseOpt>(list[i]))
  50         GenericWrapperByValue<StringOptPtr>::create(l, p);
  51       else if(UrlOptPtr p = boost::dynamic_pointer_cast<UrlOpt, BaseOpt>(list[i]))
  52         GenericWrapperByValue<UrlOptPtr>::create(l, p);
  53       else if(ColorOptPtr p = boost::dynamic_pointer_cast<ColorOpt, BaseOpt>(list[i]))
  54         GenericWrapperByValue<ColorOptPtr>::create(l, p);
  55       else if(FontOptPtr p = boost::dynamic_pointer_cast<FontOpt, BaseOpt>(list[i]))
  56         GenericWrapperByValue<FontOptPtr>::create(l, p);
  57       else if(ComboOptPtr p = boost::dynamic_pointer_cast<ComboOpt, BaseOpt>(list[i]))
  58         GenericWrapperByValue<ComboOptPtr>::create(l, p);
  59       else if(SelectOptPtr p = boost::dynamic_pointer_cast<SelectOpt, BaseOpt>(list[i]))
  60         GenericWrapperByValue<SelectOptPtr>::create(l, p);
  61       else
  62         luaL_error(l, "WFT?");
  63       return 1;
  64     }
  65   }
  66   luaL_error(l, "No item with name %s", k);
  67   return 0;
  68 }
  69
  70 void Wrapper<OptList>::create_index_table(lua_State* l) {
  71   set_meta_method(l, &to_string, "__tostring");
  72   set_meta_method(l, &newindex_event, "__newindex");
  73   set_meta_method(l, &index_event, "__index");
  74
  75   Comparable<OptList>::register_in_index_table(l);
  76 }
  77
  78 int Wrapper<OptList>::constructor(lua_State* l) {
  79   const int n = lua_gettop(l);
  80
  81   if(n!=1)
  82     luaL_error(l, "Wrong parameter list for OptList constructor");
  83
  84   OptList list;
  85   lua_pushnil(l);
  86   while (lua_next(l, -2) != 0) {
  87     if(BoolOptPtr *p = Wrapper<BoolOptPtr>::retrieve(l, -1))
  88       list << BoolOptPtr(*p);
  89     else if(IntOptPtr *p = Wrapper<IntOptPtr>::retrieve(l, -1))
  90       list << IntOptPtr(*p);
  91     else if(StringOptPtr *p = Wrapper<StringOptPtr>::retrieve(l, -1))
  92       list << StringOptPtr(*p);
  93     else if(UrlOptPtr *p = Wrapper<UrlOptPtr>::retrieve(l, -1))
  94       list << UrlOptPtr(*p);
  95     else if(ColorOptPtr *p = Wrapper<ColorOptPtr>::retrieve(l, -1))
  96       list << ColorOptPtr(*p);
  97     else if(FontOptPtr *p = Wrapper<FontOptPtr>::retrieve(l, -1))
  98       list << FontOptPtr(*p);
  99     else if(ComboOptPtr *p = Wrapper<ComboOptPtr>::retrieve(l, -1))
 100       list << ComboOptPtr(*p);
 101     else if(SelectOptPtr *p = Wrapper<SelectOptPtr>::retrieve(l, -1))
 102       list << SelectOptPtr(*p);
 103     else
 104       luaL_error(l, "Wrong item in list for OptList constructor");
 105     lua_pop(l, 1);
 106   }
 107   lua_pop(l, n);
 108
 109 //   for(int i=0;i<list.size();i++)
 110 //     std::cout << "list[" << i << "] = " << list[i]->name() << std::endl;
 111   create(l, list);
 112   return 1;
 113 }
 114
 115 //END Wrapper<OptList> ---------------------------------------------------------
 116
 117
 118 //BEGIN Wrapper<BoolOptList> -------------------------------------------------------
 119
 120 const char* Wrapper<BoolOptList>::class_name() {
 121   return "BoolOptList";
 122 }
 123
 124 int Wrapper<BoolOptList>::to_string(lua_State* l) {
 125   BoolOptList r = *retrieve(l, 1, AssertOk);
 126   QString s;
 127   for(int i=0;i<r.size();i++)
 128     s += (i==0?"":",")+r[i]->name();
 129   s = "bool_list["+s+"]";
 130   lua_pop(l, 1);
 131   lua_pushstring(l, s.toAscii().constData());
 132   return 1;
 133 }
 134
 135 int Wrapper<BoolOptList>::newindex_event(lua_State* l) {
 136   lua_pop(l,3);
 137   luaL_error(l, "BoolOptList cannot be modified after being constructed!!!");
 138   return 0;
 139 }
 140
 141 int Wrapper<BoolOptList>::index_event(lua_State* l) {
 142   const char *k = lua_tostring(l, -1);
 143   BoolOptList& list = *retrieve(l, -2);
 144   lua_pop(l,2);
 145   for(int i=0; i<list.size();i++) {
 146     if(list[i]->name() == k) {
 147       GenericWrapperByValue<BoolOptPtr>::create(l, list[i]);
 148       return 1;
 149     }
 150   }
 151   luaL_error(l, "No bool item with name %s", k);
 152   return 0;
 153 }
 154
 155 void Wrapper<BoolOptList>::create_index_table(lua_State* l) {
 156   set_meta_method(l, &to_string, "__tostring");
 157   set_meta_method(l, &newindex_event, "__newindex");
 158   set_meta_method(l, &index_event, "__index");
 159
 160   Comparable<BoolOptList>::register_in_index_table(l);
 161 }
 162
 163 int Wrapper<BoolOptList>::constructor(lua_State* l) {
 164   const int n = lua_gettop(l);
 165
 166   if(n!=1)
 167     luaL_error(l, "Wrong parameter list for BoolOptList constructor");
 168
 169   BoolOptList list;
 170   lua_pushnil(l);
 171   while (lua_next(l, -2) != 0) {
 172     list << *Wrapper<BoolOptPtr>::retrieve(l, -1, AssertOk);
 173     lua_pop(l, 1);
 174   }
 175   lua_pop(l, n);
 176
 177   create(l, list);
 178   return 1;
 179 }
 180
 181 //END Wrapper<BoolOptList> ---------------------------------------------------------
 182
 183
 184 //BEGIN Wrapper<BoolOptPtr> -------------------------------------------------------
 185
 186 const char* Wrapper<BoolOptPtr>::class_name() {
 187   return "BoolOpt";
 188 }
 189
 190 int Wrapper<BoolOptPtr>::to_string(lua_State* l) {
 191   BoolOptPtr r = *retrieve(l, 1, AssertOk);
 192   lua_pop(l, 1);
 193   lua_pushfstring(l, "bool[%s] = %s", r->name().toAscii().constData(), r->value()?"true":"false" );
 194   return 1;
 195 }
 196
 197 void Wrapper<BoolOptPtr>::create_index_table(lua_State* l) {
 198   SET_PROPERTY_RO(l, name);
 199   SET_PROPERTY_RO(l, label);
 200   SET_PROPERTY_RO(l, sub_options);
 201   SET_PROPERTY_RW(l, value);
 202   set_meta_method(l, &to_string, "__tostring");
 203
 204   Comparable<BoolOptPtr>::register_in_index_table(l);
 205 }
 206
 207 int Wrapper<BoolOptPtr>::constructor(lua_State* l) {
 208   const int n = lua_gettop(l);
 209
 210   if(n<3 || n>4)
 211     luaL_error(l, "Wrong parameter list for BoolOpt constructor");
 212
 213   const char* name = lua_tostring(l, 1);
 214   const char* label = lua_tostring(l, 2);
 215   bool value = lua_toboolean(l, 3);
 216   OptList sub_opt;
 217   if(n==4)
 218     sub_opt = *Wrapper<OptList>::retrieve(l, 4, AssertOk);
 219
 220   lua_pop(l, n);
 221   create(l, BoolOptPtr(new BoolOpt(name, label, value, sub_opt)));
 222   return 1;
 223 }
 224
 225 //END Wrapper<BoolOptPtr> ---------------------------------------------------------
 226
 227
 228 //BEGIN Wrapper<IntOptPtr> -------------------------------------------------------
 229
 230 const char* Wrapper<IntOptPtr>::class_name() {
 231   return "IntOpt";
 232 }
 233
 234 int Wrapper<IntOptPtr>::to_string(lua_State* l) {
 235   IntOptPtr r = *retrieve(l, 1, AssertOk);
 236   lua_pop(l, 1);
 237   lua_pushfstring(l, "int[%s] = %d", r->name().toAscii().constData(), r->value() );
 238   return 1;
 239 }
 240
 241 void Wrapper<IntOptPtr>::create_index_table(lua_State* l) {
 242   SET_PROPERTY_RO(l, name);
 243   SET_PROPERTY_RO(l, label);
 244   SET_PROPERTY_RO(l, min);
 245   SET_PROPERTY_RO(l, max);
 246   SET_PROPERTY_RW(l, value);
 247   SET_PROPERTY_RO(l, visualization);
 248   set_meta_method(l, &to_string, "__tostring");
 249
 250   Comparable<IntOptPtr>::register_in_index_table(l);
 251 }
 252
 253 int Wrapper<IntOptPtr>::constructor(lua_State* l) {
 254   const int n = lua_gettop(l);
 255
 256   if(n<5 || n>6)
 257     luaL_error(l, "Wrong parameter list for IntOpt constructor");
 258
 259   const char* name = lua_tostring(l, 1);
 260   const char* label = lua_tostring(l, 2);
 261   int value = int(lua_tonumber(l, 3));
 262   int min = int(lua_tonumber(l, 4));
 263   int max = int(lua_tonumber(l, 5));
 264
 265   IntOpt::Visualization visualization = IntOpt::SpinBox;
 266   if (n > 5) {
 267     QString vstring = lua_tostring(l, 6);
 268     if (vstring.compare("slider", Qt::CaseInsensitive) == 0) {
 269       visualization = IntOpt::Slider;
 270     }
 271     else if (vstring.compare("spinbox", Qt::CaseInsensitive) != 0) {
 272       ERROR("No such visualization `" << vstring << "'. Using `spinbox' instead");
 273     }
 274   }
 275
 276   lua_pop(l, n);
 277   create(l, IntOptPtr(new IntOpt(name, label, value, min, max, visualization)) );
 278   return 1;
 279 }
 280
 281 //END Wrapper<IntOptPtr> ---------------------------------------------------------
 282
 283
 284 //BEGIN Wrapper<StringOptPtr> -------------------------------------------------------
 285
 286 const char* Wrapper<StringOptPtr>::class_name() {
 287   return "StringOpt";
 288 }
 289
 290 int Wrapper<StringOptPtr>::to_string(lua_State* l) {
 291   StringOptPtr r = *retrieve(l, 1, AssertOk);
 292   lua_pop(l, 1);
 293   lua_pushfstring(l, "string[%s] = %s", r->name().toAscii().constData(), r->value().toAscii().constData() );
 294   return 1;
 295 }
 296
 297 void Wrapper<StringOptPtr>::create_index_table(lua_State* l) {
 298   SET_PROPERTY_RO(l, name);
 299   SET_PROPERTY_RO(l, label);
 300   SET_PROPERTY_RW(l, value);
 301   set_meta_method(l, &to_string, "__tostring");
 302
 303   Comparable<StringOptPtr>::register_in_index_table(l);
 304 }
 305
 306 int Wrapper<StringOptPtr>::constructor(lua_State* l) {
 307   const int n = lua_gettop(l);
 308
 309   if(n!=3)
 310     luaL_error(l, "Wrong parameter list for StringOpt constructor");
 311
 312   const char* name = lua_tostring(l, 1);
 313   const char* label = lua_tostring(l, 2);
 314   const char* value = lua_tostring(l, 3);
 315   lua_pop(l, n);
 316
 317   create(l, StringOptPtr(new StringOpt(name, label, value)));
 318   return 1;
 319 }
 320
 321 //END Wrapper<StringOptPtr> ---------------------------------------------------------
 322
 323
 324 //BEGIN Wrapper<UrlOptPtr> -------------------------------------------------------
 325
 326 const char* Wrapper<UrlOptPtr>::class_name() {
 327   return "UrlOpt";
 328 }
 329
 330 int Wrapper<UrlOptPtr>::to_string(lua_State* l) {
 331   UrlOptPtr r = *retrieve(l, 1, AssertOk);
 332   lua_pop(l, 1);
 333   lua_pushfstring(l, "url[%s] = %s", r->name().toAscii().constData(), r->value().toAscii().constData() );
 334   return 1;
 335 }
 336
 337 void Wrapper<UrlOptPtr>::create_index_table(lua_State* l) {
 338   SET_PROPERTY_RO(l, name);
 339   SET_PROPERTY_RO(l, label);
 340   SET_PROPERTY_RW(l, value);
 341   set_meta_method(l, &to_string, "__tostring");
 342
 343   Comparable<UrlOptPtr>::register_in_index_table(l);
 344 }
 345
 346 int Wrapper<UrlOptPtr>::constructor(lua_State* l) {
 347   const int n = lua_gettop(l);
 348
 349   if(n!=3)
 350     luaL_error(l, "Wrong parameter list for UrlOpt constructor");
 351
 352   const char* name = lua_tostring(l, 1);
 353   const char* label = lua_tostring(l, 2);
 354   const char* value = lua_tostring(l, 3);
 355   lua_pop(l, n);
 356
 357   create(l, UrlOptPtr(new UrlOpt(name, label, file_path(l, value) )));
 358   return 1;
 359 }
 360
 361 //END Wrapper<UrlOptPtr> ---------------------------------------------------------
 362
 363
 364 //BEGIN Wrapper<ColorOptPtr> -------------------------------------------------------
 365
 366 const char* Wrapper<ColorOptPtr>::class_name() {
 367   return "ColorOpt";
 368 }
 369
 370 int Wrapper<ColorOptPtr>::to_string(lua_State* l) {
 371   ColorOptPtr r = *retrieve(l, 1, AssertOk);
 372   lua_pop(l, 1);
 373   lua_pushfstring(l, "color[%s] = %s", r->name().toAscii().constData(), r->value().name().toAscii().constData() );
 374   return 1;
 375 }
 376
 377 void Wrapper<ColorOptPtr>::create_index_table(lua_State* l) {
 378   SET_PROPERTY_RO(l, name);
 379   SET_PROPERTY_RO(l, label);
 380   SET_PROPERTY_RW(l, value);
 381   set_meta_method(l, &to_string, "__tostring");
 382
 383   Comparable<ColorOptPtr>::register_in_index_table(l);
 384 }
 385
 386 int Wrapper<ColorOptPtr>::constructor(lua_State* l) {
 387   const int n = lua_gettop(l);
 388
 389   if(n!=3)
 390     luaL_error(l, "Wrong parameter list for ColorOpt constructor");
 391
 392   const char* name = lua_tostring(l, 1);
 393   const char* label = lua_tostring(l, 2);
 394   QColor value = Wrapper<QColor>::get(l, 3);
 395   lua_pop(l, n);
 396
 397   create(l, ColorOptPtr(new ColorOpt(name, label, value)));
 398   return 1;
 399 }
 400
 401 //END Wrapper<ColorOptPtr> ---------------------------------------------------------
 402
 403
 404 //BEGIN Wrapper<FontOptPtr> -------------------------------------------------------
 405
 406 const char* Wrapper<FontOptPtr>::class_name() {
 407   return "FontOpt";
 408 }
 409
 410 int Wrapper<FontOptPtr>::to_string(lua_State* l) {
 411   FontOptPtr r = *retrieve(l, 1, AssertOk);
 412   lua_pop(l, 1);
 413   lua_pushfstring(l, "font[%s] = %s", r->name().toAscii().constData(), r->value().toString().toAscii().constData() );
 414   return 1;
 415 }
 416
 417 void Wrapper<FontOptPtr>::create_index_table(lua_State* l) {
 418   SET_PROPERTY_RO(l, name);
 419   SET_PROPERTY_RO(l, label);
 420   SET_PROPERTY_RW(l, value);
 421   set_meta_method(l, &to_string, "__tostring");
 422
 423   Comparable<FontOptPtr>::register_in_index_table(l);
 424 }
 425
 426 int Wrapper<FontOptPtr>::constructor(lua_State* l) {
 427   const int n = lua_gettop(l);
 428
 429   if(n!=3)
 430     luaL_error(l, "Wrong parameter list for FontOpt constructor");
 431
 432   const char* name = lua_tostring(l, 1);
 433   const char* label = lua_tostring(l, 2);
 434   QFont* value = Wrapper<QFont>::retrieve(l, 3, AssertOk);
 435   lua_pop(l, n);
 436
 437   create(l, FontOptPtr(new FontOpt(name, label, *value)));
 438   return 1;
 439 }
 440
 441 //END Wrapper<FontOptPtr> ---------------------------------------------------------
 442
 443
 444 //BEGIN Wrapper<ComboOptPtr> -------------------------------------------------------
 445
 446 const char* Wrapper<ComboOptPtr>::class_name() {
 447   return "ComboOpt";
 448 }
 449
 450 int Wrapper<ComboOptPtr>::to_string(lua_State* l) {
 451   ComboOptPtr r = *retrieve(l, 1, AssertOk);
 452   lua_pop(l, 1);
 453   lua_pushfstring(l, "combo[%s] = %s",
 454                         r->name().toAscii().constData(),
 455                         r->values().join(",").toAscii().constData() );
 456   return 1;
 457 }
 458
 459 void Wrapper<ComboOptPtr>::create_index_table(lua_State* l) {
 460   SET_PROPERTY_RO(l, name);
 461   SET_PROPERTY_RO(l, label);
 462   SET_PROPERTY_RW(l, selected);
 463   set_meta_method(l, &to_string, "__tostring");
 464
 465   Comparable<ComboOptPtr>::register_in_index_table(l);
 466 }
 467
 468 int Wrapper<ComboOptPtr>::constructor(lua_State* l) {
 469   const int n = lua_gettop(l);
 470
 471   if(n<3 || n>4)
 472     luaL_error(l, "Wrong parameter list for ComboOpt constructor");
 473
 474   const char* name = lua_tostring(l, 1);
 475   const char* label = lua_tostring(l, 2);
 476   int selected = n==4 ? int(lua_tonumber(l, 4)) : 0;
 477   QStringList values;
 478   lua_pushnil(l);
 479   while (lua_next(l, 3) != 0) {
 480     values << lua_tostring(l, -1);
 481     lua_pop(l, 1);
 482   }
 483
 484   lua_pop(l, n);
 485   create(l, ComboOptPtr(new ComboOpt(name, label, values, selected)));
 486   return 1;
 487 }
 488
 489 //END Wrapper<ComboOptPtr> ---------------------------------------------------------
 490
 491
 492 //BEGIN Wrapper<SelectOptPtr> -------------------------------------------------------
 493
 494 const char* Wrapper<SelectOptPtr>::class_name() {
 495   return "SelectOpt";
 496 }
 497
 498 int Wrapper<SelectOptPtr>::to_string(lua_State* l) {
 499   SelectOptPtr r = *retrieve(l, 1, AssertOk);
 500   lua_pop(l, 1);
 501   lua_pushfstring(l, "select[%s] = !!", r->name().toAscii().constData() );
 502   return 1;
 503 }
 504
 505 void Wrapper<SelectOptPtr>::create_index_table(lua_State* l) {
 506   SET_PROPERTY_RO(l, name);
 507   SET_PROPERTY_RO(l, label);
 508   SET_PROPERTY_RO(l, options);
 509   SET_PROPERTY_RW(l, selected);
 510   set_meta_method(l, &to_string, "__tostring");
 511
 512   Comparable<SelectOptPtr>::register_in_index_table(l);
 513 }
 514
 515 int Wrapper<SelectOptPtr>::constructor(lua_State* l) {
 516   const int n = lua_gettop(l);
 517
 518   if(n<3 || n>4)
 519     luaL_error(l, "Wrong parameter list for SelectOpt constructor");
 520
 521   const char* name = lua_tostring(l, 1);
 522   const char* label = lua_tostring(l, 2);
 523   BoolOptList values = *Wrapper<BoolOptList>::retrieve(l, 3, AssertOk);
 524   int selected = n==4 ? int(lua_tonumber(l, 4)) : 0;
 525
 526   lua_pop(l, n);
 527   create(l, SelectOptPtr(new SelectOpt(name, label, values, selected)));
 528   return 1;
 529 }
 530
 531 //END Wrapper<SelectOptPtr> ---------------------------------------------------------
 532
 533
 534 } //end namespace luaapi
 535