src/frontends/qt4/GuiListings.cpp

   1 /**
   2  * \file GuiListings.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Bo Peng
   7  * \author Jürgen Spitzmüller
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "GuiListings.h"
  15
  16 #include "qt_helpers.h"
  17
  18 #include "FuncRequest.h"
  19
  20 #include "insets/InsetListings.h"
  21 #include "insets/InsetListingsParams.h"
  22
  23 #include "support/convert.h"
  24 #include "support/debug.h"
  25 #include "support/gettext.h"
  26 #include "support/lstrings.h"
  27
  28 #include <QLineEdit>
  29 #include <QPushButton>
  30 #include <QValidator>
  31 #include <QRegExpValidator>
  32
  33 using namespace std;
  34 using namespace lyx::support;
  35
  36 namespace lyx {
  37 namespace frontend {
  38
  39
  40 /////////////////////////////////////////////////////////////////////
  41 //
  42 // GuiListings
  43 //
  44 /////////////////////////////////////////////////////////////////////
  45
  46
  47 char const * languages[] =
  48 { "no language", "ABAP", "ACSL", "Ada", "ALGOL", "Assembler", "Awk", "bash", "Basic", "C",
  49   "C++", "Caml", "Clean", "Cobol", "Comal 80", "command.com", "Comsol", "csh", "Delphi",
  50   "Eiffel", "Elan", "erlang", "Euphoria", "Fortran", "Gnuplot", "Haskell", "HTML", "IDL", "inform",
  51   "Java", "JVMIS", "ksh", "Lingo", "Lisp", "Logo", "make", "Mathematica", "Matlab", "Mercury",
  52   "MetaPost", "Miranda", "ML", "Modula-2", "MuPAD", "NASTRAN", "Oberon-2", "OCL", "Octave",
  53   "Oz", "Pascal", "Perl", "PHP", "PL/I", "Plasm", "PostScript", "POV", "Prolog", "Promela",
  54   "PSTricks", "Python", "R", "Reduce", "Rexx", "RSL", "Ruby", "S", "SAS", "Scilab", "sh",
  55   "SHELXL", "Simula", "tcl", "SPARQL", "SQL", "tcl", "TeX", "VBScript", "Verilog", "VHDL",
  56   "VRML", "XML", "XSLT", "" };
  57
  58
  59 char const * languages_gui[] =
  60 { N_("No language"), "ABAP", "ACSL", "Ada", "ALGOL", "Assembler", "Awk", "bash", "Basic",
  61   "C", "C++", "Caml", "Clean", "Cobol", "Comal 80", "command.com", "Comsol", "csh", "Delphi",
  62   "Eiffel", "Elan", "Erlang", "Euphoria", "Fortran", "Gnuplot", "Haskell", "HTML", "IDL", "inform",
  63   "Java", "JVMIS", "ksh", "Lingo", "Lisp", "Logo", "make", "Mathematica", "Matlab", "Mercury",
  64   "MetaPost", "Miranda", "ML", "Modula-2", "MuPAD", "NASTRAN", "Oberon-2", "OCL", "Octave",
  65   "Oz", "Pascal", "Perl", "PHP", "PL/I", "Plasm", "PostScript", "POV", "Prolog", "Promela",
  66   "PSTricks", "Python", "R", "Reduce", "Rexx", "RSL", "Ruby", "S", "SAS", "Scilab", "sh",
  67   "SHELXL", "Simula", "tcl", "SPARQL", "SQL", "tcl", "TeX", "VBScript", "Verilog", "VHDL",
  68   "VRML", "XML", "XSLT", "" };
  69
  70
  71 struct dialect_info {
  72         /// the dialect
  73         char const * dialect;
  74         /// the associated language
  75         char const * language;
  76         /// representation of the dialect in the gui
  77         char const * gui;
  78         /// is this the default dialect?
  79         bool is_default;
  80 };
  81
  82
  83 dialect_info const dialects[] = {
  84         { "R/2 4.3", "ABAP", "R/2 4.3", false },
  85         { "R/2 5.0", "ABAP", "R/2 5.0", false },
  86         { "R/3 3.1", "ABAP", "R/3 3.1", false },
  87         { "R/3 4.6C", "ABAP", "R/3 4.6C", false },
  88         { "R/3 6.10", "ABAP", "R/3 6.10", true },
  89         { "2005", "Ada", "2005", true },
  90         { "83", "Ada", "83", false },
  91         { "95", "Ada", "95", false },
  92         { "60", "Algol", "60", false },
  93         { "68", "Algol", "68", true },
  94         { "Motorola68k", "Assembler", "Motorola 68xxx", false },
  95         { "x86masm", "Assembler", "x86 (MASM)", false },
  96         { "gnu", "Awk", "gnu", true },
  97         { "POSIX", "Awk", "POSIX", false },
  98         { "Visual", "Basic", "Visual", false },
  99         { "ANSI", "C", "ANSI", true },
 100         { "Handel", "C", "Handel", false },
 101         { "Objective", "C", "Objective", false },
 102         { "Sharp", "C", "Sharp", false },
 103         { "ANSI", "C++", "ANSI", false },
 104         { "GNU", "C++", "GNU", false },
 105         { "ISO", "C++", "ISO", true },
 106         { "Visual", "C++", "Visual", false },
 107         { "light", "Caml", "light", true },
 108         { "Objective", "Caml", "Objective", false },
 109         { "1974", "Cobol", "1974", false },
 110         { "1985", "Cobol", "1985", true },
 111         { "ibm", "Cobol", "IBM", false },
 112         { "WinXP", "command.com", "Windows XP", true },
 113         { "77", "Fortran", "77", false },
 114         { "90", "Fortran", "90", false },
 115         { "95", "Fortran", "95", true },
 116         { "CORBA", "IDL", "CORBA", false },
 117         { "AspectJ", "Java", "Aspect J", false },
 118         { "Auto", "Lisp", "Auto", false },
 119         { "gnu", "make", "gnu", false },
 120         { "1.0", "Mathematica", "1.0", false },
 121         { "3.0", "Mathematica", "3.0", false },
 122         { "5.2", "Mathematica", "5.2", true },
 123         { "decorative", "OCL", "decorative", false },
 124         { "OMG", "OCL", "OMG", true },
 125         { "Borland6", "Pascal", "Borland 6", false },
 126         { "Standard", "Pascal", "Standard", true },
 127         { "XSC", "Pascal", "XSC", false },
 128         { "PLUS", "S", "PLUS", false },
 129         { "67", "Simula", "67", true },
 130         { "CII", "Simula", "CII", false },
 131         { "DEC", "Simula", "DEC", false },
 132         { "IBM", "Simula", "IBM", false },
 133         { "tk", "tcl", "tk", false },
 134         { "AlLaTeX", "TeX", "AlLaTeX", false },
 135         { "common", "TeX", "common", false },
 136         { "LaTeX", "TeX", "LaTeX", false },
 137         { "plain", "TeX", "plain", true },
 138         { "primitive", "TeX", "primitive", false },
 139         { "AMS", "VHDL", "AMS", false },
 140         { "97", "VRML", "97", true }
 141 };
 142
 143
 144 size_t const nr_dialects = sizeof(dialects) / sizeof(dialect_info);
 145
 146
 147 char const * font_sizes[] =
 148 { "default", "tiny", "scriptsize", "footnotesize", "small", "normalsize", "large",
 149   "Large", "" };
 150
 151 char const * font_sizes_gui[] =
 152 { N_("Default"), N_("Tiny"), N_("Smallest"), N_("Smaller"), N_("Small"), N_("Normal"),
 153   N_("Large"), N_("Larger"), "" };
 154
 155 char const * font_styles[] =
 156 { "default", "rmfamily", "ttfamily", "sffamily", "" };
 157
 158 char const * font_styles_gui[] =
 159 { N_("Default"), N_("Roman"), N_("Typewriter"), N_("Sans Serif"), "" };
 160
 161
 162
 163 GuiListings::GuiListings(GuiView & lv)
 164         : GuiDialog(lv, "listings", qt_("Program Listing Settings"))
 165 {
 166         setupUi(this);
 167
 168         connect(okPB, SIGNAL(clicked()), this, SLOT(slotOK()));
 169         connect(applyPB, SIGNAL(clicked()), this, SLOT(slotApply()));
 170         connect(closePB, SIGNAL(clicked()), this, SLOT(slotClose()));
 171
 172         connect(languageCO, SIGNAL(currentIndexChanged(int)),
 173                 this, SLOT(change_adaptor()));
 174         connect(dialectCO, SIGNAL(currentIndexChanged(int)),
 175                 this, SLOT(change_adaptor()));
 176         connect(inlineCB, SIGNAL(clicked()),
 177                 this, SLOT(change_adaptor()));
 178         connect(floatCB, SIGNAL(clicked()),
 179                 this, SLOT(change_adaptor()));
 180         connect(placementLE, SIGNAL(textChanged(QString)),
 181                 this, SLOT(change_adaptor()));
 182         connect(numberSideCO, SIGNAL(currentIndexChanged(int)),
 183                 this, SLOT(change_adaptor()));
 184         connect(numberStepLE, SIGNAL(textChanged(QString)),
 185                 this, SLOT(change_adaptor()));
 186         connect(numberFontSizeCO, SIGNAL(currentIndexChanged(int)),
 187                 this, SLOT(change_adaptor()));
 188         connect(firstlineLE, SIGNAL(textChanged(QString)),
 189                 this, SLOT(change_adaptor()));
 190         connect(lastlineLE, SIGNAL(textChanged(QString)),
 191                 this, SLOT(change_adaptor()));
 192         connect(fontsizeCO, SIGNAL(currentIndexChanged(int)),
 193                 this, SLOT(change_adaptor()));
 194         connect(fontstyleCO, SIGNAL(currentIndexChanged(int)),
 195                 this, SLOT(change_adaptor()));
 196         connect(breaklinesCB, SIGNAL(clicked()),
 197                 this, SLOT(change_adaptor()));
 198         connect(spaceCB, SIGNAL(clicked()),
 199                 this, SLOT(change_adaptor()));
 200         connect(spaceInStringCB, SIGNAL(clicked()),
 201                 this, SLOT(change_adaptor()));
 202         connect(tabsizeSB, SIGNAL(valueChanged(int)),
 203                 this, SLOT(change_adaptor()));
 204         connect(extendedcharsCB, SIGNAL(clicked()),
 205                 this, SLOT(change_adaptor()));
 206
 207         connect(listingsED,  SIGNAL(textChanged()),
 208                 this, SLOT(change_adaptor()));
 209         connect(listingsED,  SIGNAL(textChanged()),
 210                 this, SLOT(setListingsMsg()));
 211         connect(bypassCB, SIGNAL(clicked()),
 212                 this, SLOT(change_adaptor()));
 213         connect(bypassCB, SIGNAL(clicked()),
 214                 this, SLOT(setListingsMsg()));
 215
 216         for (int n = 0; languages[n][0]; ++n)
 217                 languageCO->addItem(qt_(languages_gui[n]));
 218
 219         for (int n = 0; font_styles[n][0]; ++n)
 220                 fontstyleCO->addItem(qt_(font_styles_gui[n]));
 221
 222         for (int n = 0; font_sizes[n][0]; ++n) {
 223                 QString font = qt_(font_sizes_gui[n]);
 224                 fontsizeCO->addItem(font);
 225                 numberFontSizeCO->addItem(font);
 226         }
 227
 228         // set validators
 229         numberStepLE->setValidator(new QIntValidator(0, 1000000, this));
 230         firstlineLE->setValidator(new QIntValidator(0, 1000000, this));
 231         lastlineLE->setValidator(new QIntValidator(0, 1000000, this));
 232         placementLE->setValidator(new QRegExpValidator(QRegExp("[\\*tbph]*"), this));
 233
 234         bc().setPolicy(ButtonPolicy::NoRepeatedApplyReadOnlyPolicy);
 235         bc().setOK(okPB);
 236         bc().setApply(applyPB);
 237         bc().setCancel(closePB);
 238         listingsTB->setPlainText(
 239                 qt_("Input listing parameters on the right. Enter ? for a list of parameters."));
 240
 241         updateContents();
 242
 243 }
 244
 245
 246 void GuiListings::change_adaptor()
 247 {
 248         changed();
 249 }
 250
 251
 252 string GuiListings::construct_params()
 253 {
 254         string language = languages[qMax(0, languageCO->currentIndex())];
 255         string dialect;
 256         string const dialect_gui = fromqstr(dialectCO->currentText());
 257         if (dialectCO->currentIndex() > 0) {
 258                 for (size_t i = 0; i != nr_dialects; ++i) {
 259                         if (dialect_gui == dialects[i].gui
 260                         && dialects[i].language == language
 261                         && !dialects[i].is_default) {
 262                                 dialect = dialects[i].dialect;
 263                                 break;
 264                         }
 265                 }
 266         }
 267
 268         bool float_ = floatCB->isChecked();
 269         string placement;
 270         if (placementLE->isEnabled())
 271                 placement = fromqstr(placementLE->text());
 272
 273         string numberSide;
 274         switch (qMax(0, numberSideCO->currentIndex())) {
 275         case 0:
 276                 numberSide = "none";
 277                 break;
 278         case 1:
 279                 numberSide = "left";
 280                 break;
 281         case 2:
 282                 numberSide = "right";
 283                 break;
 284         default:
 285                 numberSide = "none";
 286                 break;
 287         }
 288         string stepnumber = fromqstr(numberStepLE->text());
 289         string numberfontsize = font_sizes[qMax(0, numberFontSizeCO->currentIndex())];
 290         string firstline = fromqstr(firstlineLE->text());
 291         string lastline = fromqstr(lastlineLE->text());
 292
 293         string fontsize = font_sizes[qMax(0, fontsizeCO->currentIndex())];
 294         string fontstyle = font_styles[qMax(0, fontstyleCO->currentIndex())];
 295         string basicstyle;
 296         if (fontsize != "default")
 297                 basicstyle = "\\" + fontsize;
 298         if (fontstyle != "default")
 299                 basicstyle += "\\" + fontstyle;
 300         bool breakline = breaklinesCB->isChecked();
 301         bool space = spaceCB->isChecked();
 302         int tabsize = tabsizeSB->value();
 303         bool spaceInString = spaceInStringCB->isChecked();
 304         bool extendedchars = extendedcharsCB->isChecked();
 305         string extra = fromqstr(listingsED->toPlainText());
 306
 307         // compose a string
 308         InsetListingsParams par;
 309         if (language != "no language" && !contains(extra, "language=")) {
 310                 if (dialect.empty())
 311                         par.addParam("language", language);
 312                 else
 313                         par.addParam("language", "{[" + dialect + "]" + language + "}");
 314         }
 315         // this dialog uses float=placement instead of float,floatplacement=placement
 316         // because float accepts *tbph and floatplacement accepts bph.
 317         // our placement textedit is actually for the float parameter
 318         if (float_)
 319                 par.addParam("float", placement);
 320         if (numberSide != "none")
 321                 par.addParam("numbers", numberSide);
 322         if (numberfontsize != "default" && numberSide != "none")
 323                 par.addParam("numberstyle", "\\" + numberfontsize);
 324         if (!stepnumber.empty() && numberSide != "none")
 325                 par.addParam("stepnumber", stepnumber);
 326         if (!firstline.empty())
 327                 par.addParam("firstline", firstline);
 328         if (!lastline.empty())
 329                 par.addParam("lastline", lastline);
 330         if (!basicstyle.empty())
 331                 par.addParam("basicstyle", basicstyle);
 332         if (breakline)
 333                 par.addParam("breaklines", "true");
 334         if (space)
 335                 par.addParam("showspaces", "true");
 336         if (!spaceInString)
 337                 par.addParam("showstringspaces", "false");
 338         if (tabsize != 8)
 339                 par.addParam("tabsize", convert<string>(tabsize));
 340         if (extendedchars)
 341                 par.addParam("extendedchars", "true");
 342         par.addParams(extra);
 343         return par.params();
 344 }
 345
 346
 347 docstring GuiListings::validate_listings_params()
 348 {
 349         // use a cache here to avoid repeated validation
 350         // of the same parameters
 351         static string param_cache;
 352         static docstring msg_cache;
 353
 354         if (bypassCB->isChecked())
 355                 return docstring();
 356
 357         string params = construct_params();
 358         if (params != param_cache) {
 359                 param_cache = params;
 360                 msg_cache = InsetListingsParams(params).validate();
 361         }
 362         return msg_cache;
 363 }
 364
 365
 366 void GuiListings::setListingsMsg()
 367 {
 368         static bool isOK = true;
 369         docstring msg = validate_listings_params();
 370         if (msg.empty()) {
 371                 if (isOK)
 372                         return;
 373                 isOK = true;
 374                 listingsTB->setPlainText(
 375                         qt_("Input listing parameters on the right. Enter ? for a list of parameters."));
 376         } else {
 377                 isOK = false;
 378                 listingsTB->setPlainText(toqstr(msg));
 379         }
 380 }
 381
 382
 383 void GuiListings::on_floatCB_stateChanged(int state)
 384 {
 385         if (state == Qt::Checked) {
 386                 inlineCB->setChecked(false);
 387                 placementLE->setEnabled(true);
 388         } else
 389                 placementLE->setEnabled(false);
 390 }
 391
 392
 393 void GuiListings::on_inlineCB_stateChanged(int state)
 394 {
 395         if (state == Qt::Checked) {
 396                 floatCB->setChecked(false);
 397                 placementLE->setEnabled(false);
 398         }
 399 }
 400
 401
 402 void GuiListings::on_numberSideCO_currentIndexChanged(int index)
 403 {
 404         numberStepLE->setEnabled(index > 0);
 405         numberFontSizeCO->setEnabled(index > 0);
 406 }
 407
 408
 409 void GuiListings::on_languageCO_currentIndexChanged(int index)
 410 {
 411         dialectCO->clear();
 412         // 0 is "no dialect"
 413         int default_dialect = 0;
 414         dialectCO->addItem(qt_("No dialect"));
 415         string const language = languages[index];
 416
 417         for (size_t i = 0; i != nr_dialects; ++i) {
 418                 if (language == dialects[i].language) {
 419                         dialectCO->addItem(qt_(dialects[i].gui));
 420                         if (dialects[i].is_default)
 421                                 default_dialect =
 422                                         dialectCO->findText(qt_(dialects[i].gui));
 423                 }
 424         }
 425         dialectCO->setCurrentIndex(default_dialect);
 426         dialectCO->setEnabled(dialectCO->count() > 1);
 427 }
 428
 429
 430 void GuiListings::applyView()
 431 {
 432         params_.setInline(inlineCB->isChecked());
 433         params_.setParams(construct_params());
 434 }
 435
 436
 437 static string plainParam(string const & par)
 438 {
 439         // remove enclosing braces
 440         if (prefixIs(par, "{") && suffixIs(par, "}"))
 441                 return par.substr(1, par.size() - 2);
 442         return par;
 443 }
 444
 445
 446 void GuiListings::updateContents()
 447 {
 448         // set default values
 449         listingsTB->setPlainText(
 450                 qt_("Input listing parameters on the right. Enter ? for a list of parameters."));
 451         languageCO->setCurrentIndex(findToken(languages, "no language"));
 452         dialectCO->setCurrentIndex(0);
 453         floatCB->setChecked(false);
 454         placementLE->clear();
 455         numberSideCO->setCurrentIndex(0);
 456         numberStepLE->clear();
 457         numberFontSizeCO->setCurrentIndex(findToken(font_sizes, "default"));
 458         firstlineLE->clear();
 459         lastlineLE->clear();
 460         fontstyleCO->setCurrentIndex(findToken(font_styles, "default"));
 461         fontsizeCO->setCurrentIndex(findToken(font_sizes, "default"));
 462         breaklinesCB->setChecked(false);
 463         spaceCB->setChecked(false);
 464         spaceInStringCB->setChecked(true);
 465         tabsizeSB->setValue(8);
 466         extendedcharsCB->setChecked(false);
 467
 468         // set values from param string
 469         inlineCB->setChecked(params_.isInline());
 470         if (params_.isInline()) {
 471                 floatCB->setChecked(false);
 472                 placementLE->setEnabled(false);
 473         }
 474         // break other parameters and set values
 475         vector<string> pars = getVectorFromString(params_.separatedParams(), "\n");
 476         // process each of them
 477         for (vector<string>::iterator it = pars.begin();
 478             it != pars.end(); ++it) {
 479                 if (prefixIs(*it, "language=")) {
 480                         string arg = plainParam(it->substr(9));
 481                         // has dialect?
 482                         string language;
 483                         string dialect;
 484                         bool in_gui = false;
 485                         if (prefixIs(arg, "[") && contains(arg, "]")) {
 486                                 size_t end_dialect = arg.find("]");
 487                                 dialect = arg.substr(1, end_dialect - 1);
 488                                 language = arg.substr(end_dialect + 1);
 489                         } else {
 490                                 language = arg;
 491                         }
 492                         int n = findToken(languages, language);
 493                         if (n >= 0) {
 494                                 languageCO->setCurrentIndex(n);
 495                                 in_gui = true;
 496                         }
 497                         // on_languageCO_currentIndexChanged should have set dialects
 498                         if (!dialect.empty()) {
 499                                 string dialect_gui;
 500                                 for (size_t i = 0; i != nr_dialects; ++i) {
 501                                         if (dialect == dialects[i].dialect
 502                                             && dialects[i].language == language) {
 503                                                 dialect_gui = dialects[i].gui;
 504                                                 break;
 505                                         }
 506                                 }
 507                                 n = dialectCO->findText(qt_(dialect_gui));
 508                                 if (n >= 0)
 509                                         dialectCO->setCurrentIndex(n);
 510                                 else
 511                                         in_gui = false;
 512                         }
 513                         if (in_gui)
 514                                 *it = "";
 515                         languageCO->setEnabled(in_gui);
 516                         dialectCO->setEnabled(
 517                                 in_gui && dialectCO->count() > 1);
 518                 } else if (prefixIs(*it, "float")) {
 519                         floatCB->setChecked(true);
 520                         inlineCB->setChecked(false);
 521                         placementLE->setEnabled(true);
 522                         if (prefixIs(*it, "float="))
 523                                 placementLE->setText(
 524                                         toqstr(plainParam(it->substr(6))));
 525                         *it = "";
 526                 } else if (prefixIs(*it, "numbers=")) {
 527                         string s = plainParam(it->substr(8));
 528                         int n = 0;
 529                         if (s == "left")
 530                                 n = 1;
 531                         else if (s == "right")
 532                                 n = 2;
 533                         numberSideCO->setCurrentIndex(n);
 534                         *it = "";
 535                 } else if (prefixIs(*it, "stepnumber=")) {
 536                         numberStepLE->setText(
 537                                 toqstr(plainParam(it->substr(11))));
 538                         *it = "";
 539                 } else if (prefixIs(*it, "numberstyle=")) {
 540                         string par = plainParam(it->substr(12));
 541                         int n = findToken(font_sizes, par.substr(1));
 542                         if (n >= 0)
 543                                 numberFontSizeCO->setCurrentIndex(n);
 544                         *it = "";
 545                 } else if (prefixIs(*it, "firstline=")) {
 546                         firstlineLE->setText(
 547                                 toqstr(plainParam(it->substr(10))));
 548                         *it = "";
 549                 } else if (prefixIs(*it, "lastline=")) {
 550                         lastlineLE->setText(
 551                                 toqstr(plainParam(it->substr(9))));
 552                         *it = "";
 553                 } else if (prefixIs(*it, "basicstyle=")) {
 554                         string style;
 555                         string size;
 556                         for (int n = 0; font_styles[n][0]; ++n) {
 557                                 string const s = font_styles[n];
 558                                 if (contains(*it, "\\" + s)) {
 559                                         style = "\\" + s;
 560                                         break;
 561                                 }
 562                         }
 563                         for (int n = 0; font_sizes[n][0]; ++n) {
 564                                 string const s = font_sizes[n];
 565                                 if (contains(*it, "\\" + s)) {
 566                                         size = "\\" + s;
 567                                         break;
 568                                 }
 569                         }
 570                         if (plainParam(it->substr(11)) == style + size
 571                             || plainParam(it->substr(11)) == size + style) {
 572                                 if (!style.empty()) {
 573                                         int n = findToken(font_styles, style.substr(1));
 574                                         if (n >= 0)
 575                                                 fontstyleCO->setCurrentIndex(n);
 576                                 }
 577                                 if (!size.empty()) {
 578                                         int n = findToken(font_sizes, size.substr(1));
 579                                         if (n >= 0)
 580                                                 fontsizeCO->setCurrentIndex(n);
 581                                 }
 582                                 *it = "";
 583                         }
 584                 } else if (prefixIs(*it, "breaklines=")) {
 585                         breaklinesCB->setChecked(contains(*it, "true"));
 586                         *it = "";
 587                 } else if (prefixIs(*it, "showspaces=")) {
 588                         spaceCB->setChecked(contains(*it, "true"));
 589                         *it = "";
 590                 } else if (prefixIs(*it, "showstringspaces=")) {
 591                         spaceInStringCB->setChecked(contains(*it, "true"));
 592                         *it = "";
 593                 } else if (prefixIs(*it, "tabsize=")) {
 594                         tabsizeSB->setValue(convert<int>(plainParam(it->substr(8))));
 595                         *it = "";
 596                 } else if (prefixIs(*it, "extendedchars=")) {
 597                         extendedcharsCB->setChecked(contains(*it, "true"));
 598                         *it = "";
 599                 }
 600         }
 601
 602         numberStepLE->setEnabled(numberSideCO->currentIndex() > 0);
 603         numberFontSizeCO->setEnabled(numberSideCO->currentIndex() > 0);
 604         // parameters that can be handled by widgets are cleared
 605         // the rest is put to the extra edit box.
 606         string extra = getStringFromVector(pars);
 607         listingsED->setPlainText(toqstr(InsetListingsParams(extra).separatedParams()));
 608 }
 609
 610
 611 bool GuiListings::isValid()
 612 {
 613         return validate_listings_params().empty();
 614 }
 615
 616
 617 bool GuiListings::initialiseParams(string const & data)
 618 {
 619         InsetListings::string2params(data, params_);
 620         return true;
 621 }
 622
 623
 624 void GuiListings::clearParams()
 625 {
 626         params_.clear();
 627 }
 628
 629
 630 void GuiListings::dispatchParams()
 631 {
 632         string const lfun = InsetListings::params2string(params_);
 633         dispatch(FuncRequest(getLfun(), lfun));
 634 }
 635
 636
 637 void GuiListings::setParams(InsetListingsParams const & params)
 638 {
 639         params_ = params;
 640 }
 641
 642
 643 Dialog * createGuiListings(GuiView & lv) { return new GuiListings(lv); }
 644
 645
 646 } // namespace frontend
 647 } // namespace lyx
 648
 649
 650 #include "moc_GuiListings.cpp"