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