src/frontends/gtk/GPreferences.C

   1 /**
   2  * \file GPreferences.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author John Spray
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 // Too hard to make concept checks work with this file
  14 #ifdef _GLIBCXX_CONCEPT_CHECKS
  15 #undef _GLIBCXX_CONCEPT_CHECKS
  16 #endif
  17 #ifdef _GLIBCPP_CONCEPT_CHECKS
  18 #undef _GLIBCPP_CONCEPT_CHECKS
  19 #endif
  20
  21 #include "GPreferences.h"
  22 #include "ControlPrefs.h"
  23 #include "ghelpers.h"
  24
  25 #include "controllers/frnt_lang.h"
  26 #include "controllers/helper_funcs.h"
  27 #include "support/lstrings.h"
  28
  29 #include <libglademm.h>
  30
  31 using std::string;
  32 using std::vector;
  33
  34 namespace lyx {
  35 namespace frontend {
  36
  37 GPreferences::GPreferences(Dialog & parent)
  38         : GViewCB<ControlPrefs, GViewGladeB>(parent, _("Preferences"), false)
  39 {}
  40
  41
  42 void GPreferences::doBuild()
  43 {
  44         std::cerr << ">>doBuild\n";
  45         string const gladeName = findGladeFile("preferences");
  46         xml_ = Gnome::Glade::Xml::create(gladeName);
  47
  48         Gtk::Button *button;
  49         xml_->get_widget("Cancel", button);
  50         setCancel(button);
  51         xml_->get_widget("OK", button);
  52         setOK(button);
  53         xml_->get_widget("Apply", button);
  54         setApply(button);
  55         xml_->get_widget("Revert", button);
  56         setRestore(button);
  57
  58         Gtk::HBox *box = NULL;
  59
  60         // *** Screen fonts ***
  61         // FIXME: these font buttons display a dialog
  62         // with options for size and bold/etc which are
  63         // ignored
  64         xml_->get_widget("Roman", romanfontbutton_);
  65         xml_->get_widget("SansSerif", sansseriffontbutton_);
  66         xml_->get_widget("TypeWriter", typewriterfontbutton_);
  67         Gtk::SpinButton *spin;
  68         xml_->get_widget("ScreenDPI", spin);
  69         dpiadj_ = spin->get_adjustment();
  70         xml_->get_widget("Zoom", spin);
  71         zoomadj_ = spin->get_adjustment();
  72
  73         // *** Graphics ***
  74         xml_->get_widget("GraphicsColor", graphicscolorradio_);
  75         xml_->get_widget("GraphicsGrayscale", graphicsgrayscaleradio_);
  76         xml_->get_widget("GraphicsMonochrome", graphicsmonoradio_);
  77         xml_->get_widget("GraphicsDoNotDisplay", graphicsnoneradio_);
  78
  79         xml_->get_widget("InstantPreviewOn", instprevonradio_);
  80         xml_->get_widget("InstantPreviewOff", instprevoffradio_);
  81         xml_->get_widget("InstantPreviewNoMath", instprevnomathradio_);
  82
  83         // *** Keyboard ***
  84         xml_->get_widget("UseKeyboardMap", keyboardmapcheck_);
  85         xml_->get_widget("FirstKeyboardMap", keyboardmap1fcbutton_);
  86         xml_->get_widget("SecondKeyboardMap", keyboardmap2fcbutton_);
  87
  88         Gtk::FileFilter kmapfilter;
  89         kmapfilter.set_name ("LyX keyboard maps");
  90         kmapfilter.add_pattern ("*.kmap");
  91         Gtk::FileFilter allfilter;
  92         allfilter.set_name ("All files");
  93         allfilter.add_pattern ("*");
  94
  95         keyboardmap1fcbutton_->add_filter (kmapfilter);
  96         keyboardmap1fcbutton_->add_filter (allfilter);
  97         keyboardmap1fcbutton_->set_filter (kmapfilter);
  98         keyboardmap2fcbutton_->add_filter (kmapfilter);
  99         keyboardmap2fcbutton_->add_filter (allfilter);
 100         keyboardmap2fcbutton_->set_filter (kmapfilter);
 101
 102         keyboardmapcheck_->signal_toggled().connect(
 103                 sigc::mem_fun(*this, &GPreferences::keyboard_sensitivity));
 104
 105         // *** Language ***
 106
 107         xml_->get_widget("DefaultLanguage", box);
 108         box->pack_start (defaultlanguagecombo_);
 109         defaultlanguagecombo_.show();
 110         xml_->get_widget("LanguagePackage", languagepackageentry_);
 111         xml_->get_widget("CommandStart", commandstartentry_);
 112         xml_->get_widget("CommandEnd", commandendentry_);
 113         xml_->get_widget("UseBabel", usebabelcheck_);
 114         xml_->get_widget("MarkForeignLanguages", markforeigncheck_);
 115         xml_->get_widget("Global", globalcheck_);
 116         xml_->get_widget("RTLSupport", RTLsupportcheck_);
 117         xml_->get_widget("AutoBegin", autobegincheck_);
 118         xml_->get_widget("AutoEnd", autoendcheck_);
 119
 120         // Store the lang identifiers for later
 121         vector<LanguagePair> const langs = getLanguageData(false);
 122         lang_ = getSecond(langs);
 123
 124         vector<LanguagePair>::const_iterator lit  = langs.begin();
 125         vector<LanguagePair>::const_iterator const lend = langs.end();
 126         for (; lit != lend; ++lit) {
 127                 defaultlanguagecombo_.append_text(lit->first);
 128         }
 129
 130         // *** Spellchecker ***
 131         xml_->get_widget("Spellchecker", box);
 132         box->pack_start(spellcheckercombo_);
 133         spellcheckercombo_.show();
 134         xml_->get_widget("AlternativeLanguage", alternativelanguageentry_);
 135         xml_->get_widget("EscapeCharacters", escapecharactersentry_);
 136         xml_->get_widget("PersonalDictionary", personaldictionaryfcbutton_);
 137         xml_->get_widget("AcceptCompoundWords", acceptcompoundcheck_);
 138         xml_->get_widget("UseInputEncoding", useinputenccheck_);
 139
 140         Gtk::FileFilter ispellfilter;
 141         ispellfilter.set_name ("iSpell Dictionary Files");
 142         ispellfilter.add_pattern ("*.ispell");
 143
 144         personaldictionaryfcbutton_->add_filter (ispellfilter);
 145         personaldictionaryfcbutton_->add_filter (allfilter);
 146         personaldictionaryfcbutton_->set_filter (ispellfilter);
 147
 148         spellcheckercombo_.append_text ("ispell");
 149         spellcheckercombo_.append_text ("aspell");
 150         spellcheckercombo_.append_text ("hspell");
 151 #ifdef USE_PSPELL
 152         spellcheckercombo_.append_text (_("pspell (library)"));
 153 #else
 154 #ifdef USE_ASPELL
 155         spellcheckercombo_.append_text (_("aspell (library)"));
 156 #endif
 157 #endif
 158
 159
 160 }
 161
 162
 163 void GPreferences::update()
 164 {
 165         LyXRC const & rc(controller().rc());
 166
 167         std::cerr << ">> update\n";
 168
 169         // *** Screen fonts ***
 170         Glib::ustring gtk_roman_font_name = rc.roman_font_name + ", 12";
 171         std::cerr << "Rc's roman_font_name is '" << rc.roman_font_name << "'\n";
 172         std::cerr << "Our roman_font_name is '" << gtk_roman_font_name << "'\n";
 173         romanfontbutton_->set_font_name(gtk_roman_font_name);
 174         Glib::ustring gtk_sans_font_name = rc.sans_font_name + ", 12";
 175         sansseriffontbutton_->set_font_name(gtk_sans_font_name);
 176         Glib::ustring gtk_typewriter_font_name = rc.typewriter_font_name + ", 12";
 177         typewriterfontbutton_->set_font_name(gtk_typewriter_font_name);
 178
 179         zoomadj_->set_value (rc.zoom);
 180         dpiadj_->set_value (rc.dpi);
 181
 182         // *** Graphics ***
 183         switch (rc.display_graphics) {
 184                 case graphics::NoDisplay:
 185                         graphicsnoneradio_->set_active();
 186                 break;
 187                 case graphics::MonochromeDisplay:
 188                         graphicsmonoradio_->set_active();
 189                 break;
 190                 case graphics::GrayscaleDisplay:
 191                         graphicsgrayscaleradio_->set_active();
 192                 break;
 193                 default:
 194                 case graphics::ColorDisplay:
 195                         graphicscolorradio_->set_active();
 196                 break;
 197         }
 198
 199         switch (rc.preview) {
 200                 case LyXRC::PREVIEW_ON:
 201                         instprevonradio_->set_active();
 202                 break;
 203                 case LyXRC::PREVIEW_NO_MATH:
 204                         instprevnomathradio_->set_active();
 205                 break;
 206                 default:
 207                 case LyXRC::PREVIEW_OFF:
 208                         instprevoffradio_->set_active();
 209                 break;
 210         }
 211
 212         // *** Keyboard ***
 213         keyboardmapcheck_->set_active (rc.use_kbmap);
 214         keyboardmap1fcbutton_->set_filename (rc.primary_kbmap);
 215         keyboardmap2fcbutton_->set_filename (rc.secondary_kbmap);
 216         keyboardmap1fcbutton_->set_sensitive (rc.use_kbmap);
 217         keyboardmap2fcbutton_->set_sensitive (rc.use_kbmap);
 218
 219         // *** Language ***
 220         int const pos = int(findPos(lang_, rc.default_language));
 221         defaultlanguagecombo_.set_active(pos);
 222
 223         languagepackageentry_->set_text(rc.language_package);
 224         commandstartentry_->set_text(rc.language_command_begin);
 225         commandendentry_->set_text(rc.language_command_end);
 226
 227         usebabelcheck_->set_active(rc.language_use_babel);
 228         markforeigncheck_->set_active(rc.mark_foreign_language);
 229         globalcheck_->set_active(rc.language_global_options);
 230         RTLsupportcheck_->set_active(rc.rtl_support);
 231         autobegincheck_->set_active(rc.language_auto_begin);
 232         autoendcheck_->set_active(rc.language_auto_end);
 233
 234         // *** Spellchecker ***
 235         spellcheckercombo_.set_active (0);
 236
 237         if (rc.isp_command == "ispell") {
 238                 spellcheckercombo_.set_active (0);
 239         } else if (rc.isp_command == "aspell") {
 240                 spellcheckercombo_.set_active (1);
 241         } else if (rc.isp_command == "hspell") {
 242                 spellcheckercombo_.set_active (2);
 243         }
 244
 245         if (rc.use_spell_lib) {
 246 #if defined(USE_ASPELL) || defined(USE_PSPELL)
 247                 spellcheckercombo_.set_active (3);
 248 #endif
 249         }
 250
 251         // FIXME: remove isp_use_alt_lang
 252         alternativelanguageentry_->set_text(rc.isp_alt_lang);
 253         // FIXME: remove isp_use_esc_chars
 254         escapecharactersentry_->set_text(rc.isp_esc_chars);
 255         // FIXME: remove isp_use_pers_dict
 256         personaldictionaryfcbutton_->set_filename(rc.isp_pers_dict);
 257         acceptcompoundcheck_->set_active(rc.isp_accept_compound);
 258         useinputenccheck_->set_active(rc.isp_use_input_encoding);
 259
 260         bc().valid();
 261 }
 262
 263
 264 void GPreferences::apply()
 265 {
 266         LyXRC & rc(controller().rc());
 267
 268         // *** Screen fonts ***
 269         LyXRC const oldrc(rc);
 270
 271         rc.roman_font_name = Pango::FontDescription(
 272                 romanfontbutton_->get_font_name()).get_family ();
 273         std::cerr << "Button's font_name is '" <<       romanfontbutton_->get_font_name() << "'\n";
 274         std::cerr << "Setting font name to :\n";
 275         std::cerr << "\t'" << Pango::FontDescription(
 276                 romanfontbutton_->get_font_name()).get_family () << "'\n";
 277         rc.roman_font_foundry = "";
 278         rc.sans_font_name = Pango::FontDescription(
 279                 sansseriffontbutton_->get_font_name()).get_family ();
 280         rc.sans_font_foundry = "";
 281         rc.typewriter_font_name = Pango::FontDescription(
 282                 typewriterfontbutton_->get_font_name()).get_family ();
 283         rc.typewriter_font_foundry = "";
 284
 285         rc.zoom = static_cast<int>(zoomadj_->get_value());
 286         rc.dpi = static_cast<int>(dpiadj_->get_value());
 287
 288         if (rc.font_sizes != oldrc.font_sizes
 289                 || rc.roman_font_name != oldrc.roman_font_name
 290                 || rc.sans_font_name != oldrc.sans_font_name
 291                 || rc.typewriter_font_name != oldrc.typewriter_font_name
 292                 || rc.zoom != oldrc.zoom || rc.dpi != oldrc.dpi) {
 293                 controller().updateScreenFonts();
 294         }
 295
 296         // *** Graphics ***
 297         if (graphicsnoneradio_->get_active())
 298                 rc.display_graphics = graphics::NoDisplay;
 299         else if (graphicsgrayscaleradio_->get_active())
 300                 rc.display_graphics = graphics::GrayscaleDisplay;
 301         else if (graphicsmonoradio_->get_active())
 302                 rc.display_graphics = graphics::MonochromeDisplay;
 303         else
 304                 rc.display_graphics = graphics::ColorDisplay;
 305
 306         if (instprevonradio_->get_active())
 307                 rc.preview = LyXRC::PREVIEW_ON;
 308         else if (instprevnomathradio_->get_active())
 309                 rc.preview = LyXRC::PREVIEW_NO_MATH;
 310         else
 311                 rc.preview = LyXRC::PREVIEW_OFF;
 312
 313         // *** Keyboard ***
 314         rc.use_kbmap = keyboardmapcheck_->get_active();
 315         if (rc.use_kbmap) {
 316                 rc.primary_kbmap = keyboardmap1fcbutton_->get_filename();
 317                 rc.secondary_kbmap = keyboardmap2fcbutton_->get_filename();
 318         }
 319
 320         // *** Language ***
 321         rc.default_language = lang_[
 322                 defaultlanguagecombo_.get_active_row_number()];
 323
 324         rc.language_package = languagepackageentry_->get_text();
 325         rc.language_command_begin = commandstartentry_->get_text();
 326         rc.language_command_end = commandendentry_->get_text();
 327
 328         rc.language_use_babel = usebabelcheck_->get_active();
 329         rc.mark_foreign_language = markforeigncheck_->get_active();
 330         rc.language_global_options = globalcheck_->get_active();
 331         rc.rtl_support = RTLsupportcheck_->get_active();
 332         rc.language_auto_begin = autobegincheck_->get_active();
 333         rc.language_auto_end = autoendcheck_->get_active();
 334
 335         // *** Spellchecker ***
 336         switch (spellcheckercombo_.get_active_row_number()) {
 337                 case 0:
 338                 case 1:
 339                 case 2:
 340                         rc.use_spell_lib = false;
 341                         rc.isp_command = spellcheckercombo_.get_active_text();
 342                         break;
 343                 case 3:
 344                         rc.use_spell_lib = true;
 345                         break;
 346         }
 347
 348         // FIXME: remove isp_use_alt_lang
 349         rc.isp_alt_lang = alternativelanguageentry_->get_text();
 350         rc.isp_use_alt_lang = !rc.isp_alt_lang.empty();
 351         // FIXME: remove isp_use_esc_chars
 352         rc.isp_esc_chars = escapecharactersentry_->get_text();
 353         rc.isp_use_esc_chars = !rc.isp_esc_chars.empty();
 354         // FIXME: remove isp_use_pers_dict
 355         rc.isp_pers_dict = personaldictionaryfcbutton_->get_filename();
 356         rc.isp_use_pers_dict = !rc.isp_pers_dict.empty();
 357         rc.isp_accept_compound = acceptcompoundcheck_->get_active();
 358         rc.isp_use_input_encoding = useinputenccheck_->get_active();
 359
 360         // Prevent Apply button ever getting disabled
 361         bc().valid();
 362 }
 363
 364
 365 void GPreferences::keyboard_sensitivity ()
 366 {
 367         bool const kbmap = keyboardmapcheck_->get_active();
 368         keyboardmap1fcbutton_->set_sensitive(kbmap);
 369         keyboardmap2fcbutton_->set_sensitive(kbmap);
 370 }
 371
 372
 373 } // namespace frontend
 374 } // namespace lyx