src/luaapi/options.cpp

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