X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ffrontends%2Fxforms%2FFormPreferences.C;h=6ea7d22e4264c313d4294b000449d4ec4317874b;hb=235f7c1d2a47b9fedd113d18909af0374c34ff41;hp=5c678d436dfcfb50bdb2a3b379ec06d8bc2e9a98;hpb=ef59101fe7f9231107b32b753fc9690474f58785;p=lyx.git diff --git a/src/frontends/xforms/FormPreferences.C b/src/frontends/xforms/FormPreferences.C index 5c678d436d..6ea7d22e42 100644 --- a/src/frontends/xforms/FormPreferences.C +++ b/src/frontends/xforms/FormPreferences.C @@ -12,244 +12,1043 @@ #include "FormPreferences.h" #include "form_preferences.h" -#include "xform_macros.h" #include "input_validators.h" #include "LyXView.h" +#include "language.h" #include "lyxfunc.h" #include "Dialogs.h" #include "lyxrc.h" +#include "combox.h" #include "debug.h" #include "support/FileInfo.h" #include "support/filetools.h" #include "lyx_gui_misc.h" -#include "gettext.h" +#include "xform_macros.h" #ifdef SIGC_CXX_NAMESPACES using SigC::slot; #endif -C_RETURNCB(FormPreferences, WMHideCB) -C_GENERICCB(FormPreferences, OKCB) -C_GENERICCB(FormPreferences, ApplyCB) -C_GENERICCB(FormPreferences, CancelCB) -C_GENERICCB(FormPreferences, InputCB) +using std::find; +using std::vector; +extern Languages languages; FormPreferences::FormPreferences(LyXView * lv, Dialogs * d) - : dialog_(0), bind_(0), misc_(0), screen_fonts_(0), - interface_fonts_(0), printer_(0), paths_(0), - lv_(lv), d_(d), u_(0), h_(0), status(DIALOG_UNMODIFIED) + : FormBaseBI(lv, d, _("Preferences"), new PreferencesPolicy), + dialog_(0), outputs_tab_(0), look_n_feel_tab_(0), inputs_tab_(0), + usage_tab_(0), colours_(0), inputs_misc_(0), interface_(0), + language_(0), lnf_misc_(0), outputs_misc_(0), paths_(0), printer_(0), + screen_fonts_(0), spellchecker_(0), + combo_default_lang(0), combo_kbmap_1(0), combo_kbmap_2(0) { // let the dialog be shown // This is a permanent connection so we won't bother // storing a copy because we won't be disconnecting. - d->showPreferences.connect(slot(this,&FormPreferences::show)); + d->showPreferences.connect(slot(this, &FormPreferences::show)); } FormPreferences::~FormPreferences() { - free(); + delete combo_default_lang; + delete combo_kbmap_1; + delete combo_kbmap_2; + + delete look_n_feel_tab_; + delete inputs_tab_; + delete outputs_tab_; + delete usage_tab_; + delete colours_; + delete inputs_misc_; + delete interface_; + delete language_; + delete lnf_misc_; + delete outputs_misc_; + delete paths_; + delete printer_; + delete screen_fonts_; + delete spellchecker_; + + // Must be last to be deleted, or we'll get a SIGSEGV. + // Something to do with the Timer mechanism. + delete dialog_; +} + + +FL_FORM * FormPreferences::form() const +{ + if (dialog_) return dialog_->form; + return 0; +} + + +void FormPreferences::ok() +{ + FormBase::ok(); + lv_->getLyXFunc()->Dispatch(LFUN_SAVEPREFERENCES); +} + + +void FormPreferences::restore() +{ + update(); +// if I add an error message line to the dialog it'll have to be controlled +// within input(). I don't need it yet so I'll leave it commented out. +// bc_.valid(input(0)); +} + + +void FormPreferences::hide() +{ + // We need to hide the active tabfolder otherwise we get a + // BadDrawable error from X windows and LyX crashes without saving. + FL_FORM * outer_form = fl_get_active_folder(dialog_->tabfolder_prefs); + if (outer_form + && outer_form->visible) { + fl_hide_form(outer_form); + } + FormBase::hide(); } void FormPreferences::build() { dialog_ = build_preferences(); - bind_ = build_bind(); - screen_fonts_ = build_screen_fonts(); - interface_fonts_ = build_interface_fonts(); - misc_ = build_misc(); - printer_ = build_printer(); - paths_ = build_paths(); - // setup the input returns - // Bind tab - fl_set_input_return(bind_->input_bind, FL_RETURN_CHANGED); - // Misc tab - fl_set_counter_return(misc_->counter_autosave, FL_RETURN_CHANGED); - fl_set_counter_return(misc_->counter_line_len, FL_RETURN_CHANGED); - // Screen fonts - fl_set_input_return(screen_fonts_->input_roman, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_sans, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_typewriter, + // manage the restore, save, apply and cancel/close buttons + bc_.setOK(dialog_->button_ok); + bc_.setApply(dialog_->button_apply); + bc_.setCancel(dialog_->button_cancel); + bc_.setUndoAll(dialog_->button_restore); + bc_.refresh(); + + // Workaround dumb xforms sizing bug + minw_ = form()->w; + minh_ = form()->h; + + // build the tab folders + outputs_tab_ = build_outer_tab(); + look_n_feel_tab_ = build_outer_tab(); + inputs_tab_ = build_outer_tab(); + usage_tab_ = build_outer_tab(); + + // build actual tabfolder contents + // these will become nested tabfolders + buildColours(); + buildInputsMisc(); + buildInterface(); + buildLanguage(); + buildLnFmisc(); + buildOutputsMisc(); + buildPaths(); + buildPrinter(); + buildScreenFonts(); + buildSpellchecker(); + + // Now add them to the tabfolder + fl_addto_tabfolder(dialog_->tabfolder_prefs, + _("Look and Feel"), + look_n_feel_tab_->form); + fl_addto_tabfolder(dialog_->tabfolder_prefs, + _("Inputs"), + inputs_tab_->form); + fl_addto_tabfolder(dialog_->tabfolder_prefs, + _("Outputs"), + outputs_tab_->form); + fl_addto_tabfolder(dialog_->tabfolder_prefs, + _("Usage"), + usage_tab_->form); + + // now build the nested tabfolders + // Starting with look and feel + fl_addto_tabfolder(look_n_feel_tab_->tabfolder_outer, + _("Screen Fonts"), + screen_fonts_->form); + fl_addto_tabfolder(look_n_feel_tab_->tabfolder_outer, + _("Interface"), + interface_->form); + fl_addto_tabfolder(look_n_feel_tab_->tabfolder_outer, + _("Colours"), + colours_->form); + fl_addto_tabfolder(look_n_feel_tab_->tabfolder_outer, + _("Misc"), + lnf_misc_->form); + + // then build inputs + // Paths should probably go in a few outer_tab called Files + fl_addto_tabfolder(inputs_tab_->tabfolder_outer, + _("Paths"), + paths_->form); + fl_addto_tabfolder(inputs_tab_->tabfolder_outer, + _("Misc"), + inputs_misc_->form); + + // then building outputs + fl_addto_tabfolder(outputs_tab_->tabfolder_outer, + _("Printer"), + printer_->form); + fl_addto_tabfolder(outputs_tab_->tabfolder_outer, + _("Misc"), + outputs_misc_->form); + + // then building usage + fl_addto_tabfolder(usage_tab_->tabfolder_outer, + _("Spell checker"), + spellchecker_->form); + fl_addto_tabfolder(usage_tab_->tabfolder_outer, + _("Language"), + language_->form); +} + + +void FormPreferences::apply() +{ + // set the new lyxrc entries + // many of these need to trigger other functions when the assignment + // is made. For example, screen zoom and font types. These could be + // handled either by signals/slots in lyxrc or just directly call the + // associated functions here. + // There are other problems with this scheme. We really should check + // what we copy to make sure that it really is necessary to do things + // like update the screen fonts because that flushes the textcache + // and other stuff which may cost us a lot on slower/high-load machines. + + applyColours(); + applyInputsMisc(); + applyInterface(); + applyLanguage(); + applyLnFmisc(); + applyOutputsMisc(); + applyPaths(); + applyPrinter(); + applyScreenFonts(); + applySpellChecker(); +} + + +void FormPreferences::feedback( FL_OBJECT * ob ) +{ + if( ob->form->fdui == colours_ ) + feedbackColours( ob ); + if( ob->form->fdui == inputs_misc_ ) + feedbackInputsMisc( ob ); + if( ob->form->fdui == interface_ ) + feedbackInterface( ob ); + if( ob->form->fdui == language_ ) + feedbackLanguage( ob ); + if( ob->form->fdui == lnf_misc_ ) + feedbackLnFmisc( ob ); + if( ob->form->fdui == outputs_misc_ ) + feedbackOutputsMisc( ob ); + if( ob->form->fdui == paths_ ) + feedbackPaths( ob ); + if( ob->form->fdui == printer_ ) + feedbackPrinter( ob ); + if( ob->form->fdui == screen_fonts_ ) + feedbackScreenFonts( ob ); + if( ob->form->fdui == spellchecker_ ) + feedbackSpellChecker( ob ); +} + + +bool FormPreferences::input(FL_OBJECT * ob, long data) +{ + bool activate = true; + + // whatever checks you need to ensure the user hasn't entered + // some totally ridiculous value somewhere. Change activate to suit. + // comments before each test describe what is _valid_ + + State cb = static_cast( data ); + switch( cb ) { + case LANGUAGE: + if( ! inputLanguage( ob ) ) + activate = false; + break; + + case PATHS: + if( ! inputPaths( ob ) ) + activate = false; + break; + + case SCREENFONTS: + if( ! inputScreenFonts() ) + activate = false; + break; + + case SPELLCHECKER: + if( ! inputSpellChecker( ob ) ) + activate = false; + break; + + default: + break; + } + + return activate; +} + + +void FormPreferences::update() +{ + if (!dialog_) return; + + // read lyxrc entries + updateColours(); + updateInputsMisc(); + updateInterface(); + updateLanguage(); + updateLnFmisc(); + updateOutputsMisc(); + updatePaths(); + updatePrinter(); + updateScreenFonts(); + updateSpellChecker(); +} + + +void FormPreferences::applyColours() +{ +} + + +void FormPreferences::buildColours() +{ + colours_ = build_colours(); +} + + +void FormPreferences::feedbackColours( FL_OBJECT const * const ) +{ +} + + +void FormPreferences::updateColours() +{ +} + + +void FormPreferences::applyInputsMisc() +{ + lyxrc.date_insert_format = fl_get_input(inputs_misc_->input_date_format); +} + + +void FormPreferences::buildInputsMisc() +{ + inputs_misc_ = build_inputs_misc(); + + fl_set_input_return(inputs_misc_->input_date_format, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_encoding, FL_RETURN_CHANGED); - fl_set_counter_return(screen_fonts_->counter_zoom, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_tiny, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_script, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_footnote, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_small, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_normal, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_large, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_larger, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_largest, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_huge, FL_RETURN_CHANGED); - fl_set_input_return(screen_fonts_->input_huger, FL_RETURN_CHANGED); - // interface fonts - fl_set_input_return(interface_fonts_->input_popup_font, + + // set up the feedback mechanism + fl_addto_form(inputs_misc_->form); + + setPostHandler( inputs_misc_->input_date_format ); + + fl_end_form(); +} + + +void FormPreferences::feedbackInputsMisc( FL_OBJECT const * const ob ) +{ + string str; + + if( ob == inputs_misc_->input_date_format ) + str = lyxrc.getFeedback( LyXRC::RC_DATE_INSERT_FORMAT ); + + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); +} + + +void FormPreferences::updateInputsMisc() +{ + fl_set_input(inputs_misc_->input_date_format, + lyxrc.date_insert_format.c_str()); +} + + +void FormPreferences::applyInterface() +{ + lyxrc.popup_font_name = + fl_get_input(interface_->input_popup_font); + lyxrc.menu_font_name = fl_get_input(interface_->input_menu_font); + lyxrc.font_norm_menu = + fl_get_input(interface_->input_popup_encoding); + lyxrc.bind_file = fl_get_input(interface_->input_bind_file); + lyxrc.ui_file = fl_get_input(interface_->input_ui_file); + lyxrc.override_x_deadkeys = + fl_get_button(interface_->check_override_x_dead_keys); +} + + +void FormPreferences::buildInterface() +{ + interface_ = build_interface(); + + fl_set_input_return(interface_->input_popup_font, FL_RETURN_CHANGED); + fl_set_input_return(interface_->input_menu_font, FL_RETURN_CHANGED); + fl_set_input_return(interface_->input_popup_encoding, + FL_RETURN_CHANGED); + fl_set_input_return(interface_->input_bind_file, FL_RETURN_CHANGED); + fl_set_input_return(interface_->input_ui_file, FL_RETURN_CHANGED); + + // deactivate the browse buttons because they aren't implemented + fl_deactivate_object(interface_->button_bind_file_browse); + fl_deactivate_object(interface_->button_ui_file_browse); + fl_set_object_lcol(interface_->button_bind_file_browse, FL_INACTIVE); + fl_set_object_lcol(interface_->button_ui_file_browse, FL_INACTIVE); + + // set up the feedback mechanism + fl_addto_form(interface_->form); + + setPostHandler( interface_->input_popup_font ); + setPostHandler( interface_->input_menu_font ); + setPostHandler( interface_->input_popup_encoding ); + setPostHandler( interface_->input_bind_file ); + setPostHandler( interface_->button_bind_file_browse ); + setPostHandler( interface_->input_ui_file ); + setPostHandler( interface_->button_ui_file_browse ); + setPostHandler( interface_->check_override_x_dead_keys ); + + fl_end_form(); +} + + + +void FormPreferences::feedbackInterface( FL_OBJECT const * const ob ) +{ + string str; + + if( ob == interface_->input_popup_font ) + str = lyxrc.getFeedback( LyXRC::RC_SCREEN_FONT_POPUP ); + else if ( ob == interface_->input_menu_font ) + str = lyxrc.getFeedback( LyXRC::RC_SCREEN_FONT_MENU ); + else if ( ob == interface_->input_popup_encoding ) + str = lyxrc.getFeedback( LyXRC::RC_SCREEN_FONT_ENCODING_MENU ); + else if ( ob == interface_->input_bind_file ) + str = lyxrc.getFeedback( LyXRC::RC_BINDFILE ); + else if ( ob == interface_->input_ui_file ) + str = lyxrc.getFeedback( LyXRC::RC_UIFILE ); + else if ( ob == interface_->check_override_x_dead_keys ) + str = lyxrc.getFeedback( LyXRC::RC_OVERRIDE_X_DEADKEYS ); + + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); +} + + +void FormPreferences::updateInterface() +{ + fl_set_input(interface_->input_popup_font, + lyxrc.popup_font_name.c_str()); + fl_set_input(interface_->input_menu_font, + lyxrc.menu_font_name.c_str()); + fl_set_input(interface_->input_popup_encoding, + lyxrc.font_norm_menu.c_str()); + fl_set_input(interface_->input_bind_file, + lyxrc.bind_file.c_str()); + fl_set_input(interface_->input_ui_file, + lyxrc.ui_file.c_str()); + fl_set_button(interface_->check_override_x_dead_keys, + lyxrc.override_x_deadkeys); +} + + +void FormPreferences::applyLanguage() +{ + lyxrc.default_language = combo_default_lang->getline(); + + int button = fl_get_button(language_->check_use_kbmap); + lyxrc.use_kbmap = static_cast(button); + + if( button ) { + lyxrc.primary_kbmap = combo_kbmap_1->getline(); + lyxrc.secondary_kbmap = combo_kbmap_2->getline(); + } + + button = fl_get_button(language_->check_rtl_support); + lyxrc.rtl_support = static_cast(button); + + button = fl_get_button(language_->check_auto_begin); + lyxrc.language_auto_begin = static_cast(button); + + button = fl_get_button(language_->check_auto_end); + lyxrc.language_auto_end = static_cast(button); + + button = fl_get_button(language_->check_mark_foreign); + lyxrc.mark_foreign_language = static_cast(button); + + lyxrc.language_package = fl_get_input(language_->input_package); + lyxrc.language_command_begin = fl_get_input(language_->input_command_begin); + lyxrc.language_command_end = fl_get_input(language_->input_command_end); +} + + +void FormPreferences::buildLanguage() +{ + language_ = build_language(); + + fl_set_input_return(language_->input_package, FL_RETURN_CHANGED); + fl_set_input_return(language_->input_command_begin, FL_RETURN_CHANGED); + fl_set_input_return(language_->input_command_end, FL_RETURN_CHANGED); + + // The default_language is a combo-box and has to be inserted manually + fl_addto_form(language_->form); + + FL_OBJECT * obj = language_->choice_default_lang; + combo_default_lang = new Combox(FL_COMBOX_DROPLIST); + combo_default_lang->add(obj->x, obj->y, obj->w, obj->h, 400); + combo_default_lang->shortcut("#L",1); + combo_default_lang->setcallback(ComboLanguageCB, this); + addLanguages( *combo_default_lang ); + + // ditto kbmap_1 + obj = language_->choice_kbmap_1; + combo_kbmap_1 = new Combox(FL_COMBOX_DROPLIST); + combo_kbmap_1->add(obj->x, obj->y, obj->w, obj->h, 400); + combo_kbmap_1->shortcut("#1",1); + combo_kbmap_1->setcallback(ComboLanguageCB, this); + addLanguages( *combo_kbmap_1 ); + + // ditto kbmap_2 + obj = language_->choice_kbmap_2; + combo_kbmap_2 = new Combox(FL_COMBOX_DROPLIST); + combo_kbmap_2->add(obj->x, obj->y, obj->w, obj->h, 400); + combo_kbmap_2->shortcut("#2",1); + combo_kbmap_2->setcallback(ComboLanguageCB, this); + addLanguages( *combo_kbmap_2 ); + + fl_end_form(); + + // set up the feedback mechanism + fl_addto_form(language_->form); + + setPostHandler( language_->input_package ); + setPostHandler( language_->check_use_kbmap ); + + // these 3 should be replaced by the appropriate combox call + // setPostHandler( reinterpret_cast(combo_default_lang) ); + // setPostHandler( reinterpret_cast(combo_kbmap_1) ); + // setPostHandler( reinterpret_cast(combo_kbmap_2) ); + + setPostHandler( language_->check_rtl_support ); + setPostHandler( language_->check_mark_foreign ); + setPostHandler( language_->check_auto_begin ); + setPostHandler( language_->check_auto_end ); + setPostHandler( language_->input_command_begin ); + setPostHandler( language_->input_command_end ); + + fl_end_form(); +} + + +void FormPreferences::addLanguages( Combox & combo ) +{ + for(Languages::const_iterator cit = languages.begin(); + cit != languages.end(); cit++) { + combo.addto((*cit).second.lang()); + } +} + + +void FormPreferences::feedbackLanguage( FL_OBJECT const * const ob ) +{ + string str; + + if( reinterpret_cast(ob) == combo_default_lang ) + str = lyxrc.getFeedback( LyXRC::RC_DEFAULT_LANGUAGE ); + else if( ob == language_->check_use_kbmap ) + str = lyxrc.getFeedback( LyXRC::RC_KBMAP ); + else if( reinterpret_cast(ob) == combo_kbmap_1) + str = lyxrc.getFeedback( LyXRC::RC_KBMAP_PRIMARY ); + else if( reinterpret_cast(ob) == combo_kbmap_2 ) + str = lyxrc.getFeedback( LyXRC::RC_KBMAP_SECONDARY ); + else if( ob == language_->check_rtl_support ) + str = lyxrc.getFeedback( LyXRC::RC_RTL_SUPPORT ); + else if( ob == language_->check_auto_begin ) + str = lyxrc.getFeedback( LyXRC::RC_LANGUAGE_AUTO_BEGIN ); + else if( ob == language_->check_auto_end ) + str = lyxrc.getFeedback( LyXRC::RC_LANGUAGE_AUTO_END ); + else if( ob == language_->check_mark_foreign ) + str = lyxrc.getFeedback( LyXRC::RC_MARK_FOREIGN_LANGUAGE ); + else if( ob == language_->input_package ) + str = lyxrc.getFeedback( LyXRC::RC_LANGUAGE_PACKAGE ); + else if( ob == language_->input_command_begin ) + str = lyxrc.getFeedback( LyXRC::RC_LANGUAGE_COMMAND_BEGIN ); + else if( ob == language_->input_command_end ) + str = lyxrc.getFeedback( LyXRC::RC_LANGUAGE_COMMAND_END ); + + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); +} + + +bool FormPreferences::inputLanguage( FL_OBJECT const * const ob ) +{ + bool activate = true; + + if( !ob || ob == language_->check_use_kbmap ) { + if( fl_get_button(language_->check_use_kbmap) ) { + combo_kbmap_1->activate(); + combo_kbmap_2->activate(); + } else { + combo_kbmap_1->deactivate(); + combo_kbmap_2->deactivate(); + } + } + + return activate; +} + + +void FormPreferences::updateLanguage() +{ + fl_set_button(language_->check_use_kbmap, + lyxrc.use_kbmap); + + combo_default_lang->select_text( lyxrc.default_language ); + + if( lyxrc.use_kbmap ) { + combo_kbmap_1->select_text( lyxrc.primary_kbmap ); + combo_kbmap_2->select_text( lyxrc.secondary_kbmap ); + } else { + combo_kbmap_1->select_text( lyxrc.default_language ); + combo_kbmap_2->select_text( lyxrc.default_language ); + } + + fl_set_button(language_->check_rtl_support, lyxrc.rtl_support); + fl_set_button(language_->check_auto_begin, lyxrc.language_auto_begin); + fl_set_button(language_->check_auto_end, lyxrc.language_auto_end); + fl_set_button(language_->check_mark_foreign, + lyxrc.mark_foreign_language); + + fl_set_input(language_->input_package, + lyxrc.language_package.c_str()); + fl_set_input(language_->input_command_begin, + lyxrc.language_command_begin.c_str()); + fl_set_input(language_->input_command_end, + lyxrc.language_command_end.c_str()); + + // Activate/Deactivate the input fields dependent on the state of the + // buttons. + inputLanguage( 0 ); +} + + +void FormPreferences::applyLnFmisc() +{ + lyxrc.show_banner = fl_get_button(lnf_misc_->check_banner); + lyxrc.auto_region_delete = fl_get_button(lnf_misc_-> + check_auto_region_delete); + lyxrc.exit_confirmation = fl_get_button(lnf_misc_->check_exit_confirm); + lyxrc.display_shortcuts = + fl_get_button(lnf_misc_->check_display_shortcuts); + lyxrc.new_ask_filename = fl_get_button(lnf_misc_->check_ask_new_file); + lyxrc.cursor_follows_scrollbar = + fl_get_button(lnf_misc_->check_cursor_follows_scrollbar); + lyxrc.autosave = static_cast + (fl_get_counter_value(lnf_misc_->counter_autosave)); + lyxrc.wheel_jump = static_cast + (fl_get_counter_value(lnf_misc_->counter_wm_jump)); +} + + +void FormPreferences::buildLnFmisc() +{ + lnf_misc_ = build_lnf_misc(); + + fl_set_counter_return(lnf_misc_->counter_autosave, + FL_RETURN_CHANGED); + fl_set_counter_return(lnf_misc_->counter_wm_jump, + FL_RETURN_CHANGED); + + // set up the feedback mechanism + fl_addto_form(lnf_misc_->form); + + setPostHandler( lnf_misc_->check_banner ); + setPostHandler( lnf_misc_->check_auto_region_delete ); + setPostHandler( lnf_misc_->check_exit_confirm ); + setPostHandler( lnf_misc_->check_display_shortcuts ); + setPostHandler( lnf_misc_->counter_autosave ); + setPostHandler( lnf_misc_->check_ask_new_file ); + setPostHandler( lnf_misc_->check_cursor_follows_scrollbar ); + setPostHandler( lnf_misc_->counter_wm_jump ); + + fl_end_form(); +} + + +void FormPreferences::feedbackLnFmisc( FL_OBJECT const * const ob ) +{ + string str; + + if( ob == lnf_misc_->check_banner ) + str = lyxrc.getFeedback( LyXRC::RC_SHOW_BANNER ); + else if( ob == lnf_misc_->check_auto_region_delete ) + str = lyxrc.getFeedback( LyXRC::RC_AUTOREGIONDELETE ); + else if( ob == lnf_misc_->check_exit_confirm ) + str = lyxrc.getFeedback( LyXRC::RC_EXIT_CONFIRMATION ); + else if( ob == lnf_misc_->check_display_shortcuts ) + str = lyxrc.getFeedback( LyXRC::RC_DISPLAY_SHORTCUTS ); + else if( ob == lnf_misc_->check_ask_new_file ) + str = lyxrc.getFeedback( LyXRC::RC_NEW_ASK_FILENAME ); + else if( ob == lnf_misc_->check_cursor_follows_scrollbar ) + str = lyxrc.getFeedback( LyXRC::RC_CURSOR_FOLLOWS_SCROLLBAR ); + else if( ob == lnf_misc_->counter_autosave ) + str = lyxrc.getFeedback( LyXRC::RC_AUTOSAVE ); + else if( ob == lnf_misc_->counter_wm_jump ) + str = lyxrc.getFeedback( LyXRC::RC_WHEEL_JUMP ); + + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); +} + +void FormPreferences::updateLnFmisc() +{ + fl_set_button(lnf_misc_->check_banner, + lyxrc.show_banner); + fl_set_button(lnf_misc_->check_auto_region_delete, + lyxrc.auto_region_delete); + fl_set_button(lnf_misc_->check_exit_confirm, + lyxrc.exit_confirmation); + fl_set_button(lnf_misc_->check_display_shortcuts, + lyxrc.display_shortcuts); + fl_set_button(lnf_misc_->check_ask_new_file, + lyxrc.new_ask_filename); + fl_set_button(lnf_misc_->check_cursor_follows_scrollbar, + lyxrc.cursor_follows_scrollbar); + fl_set_counter_value(lnf_misc_->counter_autosave, + lyxrc.autosave); + fl_set_counter_value(lnf_misc_->counter_wm_jump, + lyxrc.wheel_jump); +} + + +void FormPreferences::applyOutputsMisc() +{ + lyxrc.ascii_linelen = static_cast + (fl_get_counter_value(outputs_misc_->counter_line_len)); + lyxrc.fontenc = fl_get_input(outputs_misc_->input_tex_encoding); + + int choice = + fl_get_choice(outputs_misc_->choice_default_papersize) - 1; + lyxrc.default_papersize = static_cast(choice); + + lyxrc.ascii_roff_command = fl_get_input(outputs_misc_->input_ascii_roff); + lyxrc.chktex_command = fl_get_input(outputs_misc_->input_checktex); +} + + +void FormPreferences::buildOutputsMisc() +{ + outputs_misc_ = build_outputs_misc(); + + fl_set_counter_return(outputs_misc_->counter_line_len, + FL_RETURN_CHANGED); + fl_set_input_return(outputs_misc_->input_tex_encoding, FL_RETURN_CHANGED); - fl_set_input_return(interface_fonts_->input_menu_font, + fl_set_input_return(outputs_misc_->input_ascii_roff, FL_RETURN_CHANGED); - fl_set_input_return(interface_fonts_->input_encoding, + fl_set_input_return(outputs_misc_->input_checktex, FL_RETURN_CHANGED); - // printer - fl_set_input_return(printer_->input_command, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_page_range, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_copies, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_reverse, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_to_printer, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_file_extension, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_spool_command, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_paper_type, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_even_pages, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_odd_pages, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_collated, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_landscape, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_to_file, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_extra_options, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_spool_prefix, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_paper_size, FL_RETURN_CHANGED); - fl_set_input_return(printer_->input_name, FL_RETURN_CHANGED); - // paths + fl_addto_choice(outputs_misc_->choice_default_papersize, + _(" default | US letter | legal | executive | A3 | A4 | A5 | B5 ")); + + // set up the feedback mechanism + fl_addto_form(outputs_misc_->form); + + setPostHandler( outputs_misc_->counter_line_len ); + setPostHandler( outputs_misc_->input_tex_encoding ); + setPostHandler( outputs_misc_->choice_default_papersize ); + setPostHandler( outputs_misc_->input_ascii_roff ); + setPostHandler( outputs_misc_->input_checktex ); + + fl_end_form(); +} + + +void FormPreferences::feedbackOutputsMisc(FL_OBJECT const * const ob ) +{ + string str; + + if( ob == outputs_misc_->counter_line_len ) + str = lyxrc.getFeedback( LyXRC::RC_ASCII_LINELEN ); + else if( ob == outputs_misc_->input_tex_encoding ) + str = lyxrc.getFeedback( LyXRC::RC_FONT_ENCODING ); + else if( ob == outputs_misc_->input_ascii_roff ) + str = lyxrc.getFeedback( LyXRC::RC_ASCIIROFF_COMMAND ); + else if( ob == outputs_misc_->input_checktex ) + str = lyxrc.getFeedback( LyXRC::RC_CHKTEX_COMMAND ); + else if( ob == outputs_misc_->choice_default_papersize ) + str = lyxrc.getFeedback( LyXRC::RC_DEFAULT_PAPERSIZE ); + + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); +} + + +void FormPreferences::updateOutputsMisc() +{ + fl_set_counter_value(outputs_misc_->counter_line_len, + lyxrc.ascii_linelen); + fl_set_input(outputs_misc_->input_tex_encoding, + lyxrc.fontenc.c_str()); + fl_set_choice(outputs_misc_->choice_default_papersize, + lyxrc.default_papersize+1); + fl_set_input(outputs_misc_->input_ascii_roff, + lyxrc.ascii_roff_command.c_str()); + fl_set_input(outputs_misc_->input_checktex, + lyxrc.chktex_command.c_str()); +} + + +void FormPreferences::applyPaths() +{ + lyxrc.document_path = fl_get_input(paths_->input_default_path); + lyxrc.template_path = fl_get_input(paths_->input_template_path); + + int button = fl_get_button(paths_->check_use_temp_dir); + string str = fl_get_input(paths_->input_temp_dir); + if( !button ) str.erase(); + + lyxrc.use_tempdir = button; + lyxrc.tempdir_path = str; + + button = fl_get_button(paths_->check_last_files); + str = fl_get_input(paths_->input_lastfiles); + if( !button ) str.erase(); + + lyxrc.check_lastfiles = button; + lyxrc.lastfiles = str; + lyxrc.num_lastfiles = static_cast + (fl_get_counter_value(paths_->counter_lastfiles)); + + button = fl_get_button(paths_->check_make_backups); + str = fl_get_input(paths_->input_backup_path); + if( !button ) str.erase(); + + lyxrc.make_backup = button; + lyxrc.backupdir_path = str; + + lyxrc.lyxpipes = fl_get_input(paths_->input_serverpipe); + + // update view + updatePaths(); +} + + +void FormPreferences::buildPaths() +{ + paths_ = build_paths(); + fl_set_input_return(paths_->input_default_path, FL_RETURN_CHANGED); fl_set_input_return(paths_->input_template_path, FL_RETURN_CHANGED); fl_set_input_return(paths_->input_temp_dir, FL_RETURN_CHANGED); fl_set_input_return(paths_->input_lastfiles, FL_RETURN_CHANGED); fl_set_input_return(paths_->input_backup_path, FL_RETURN_CHANGED); fl_set_counter_return(paths_->counter_lastfiles, FL_RETURN_CHANGED); + fl_set_input_return(paths_->input_serverpipe, FL_RETURN_CHANGED); - // Now add them to the tabfolder - fl_addto_tabfolder(dialog_->tabfolder_prefs, - _("Bindings"), - bind_->form_bind); - fl_addto_tabfolder(dialog_->tabfolder_prefs, - _("Screen Fonts"), - screen_fonts_->form_screen_fonts); - fl_addto_tabfolder(dialog_->tabfolder_prefs, - _("Interface Fonts"), - interface_fonts_->form_interface_fonts); - fl_addto_tabfolder(dialog_->tabfolder_prefs, - _("Miscellaneous"), - misc_->form_misc); - fl_addto_tabfolder(dialog_->tabfolder_prefs, - _("Printer"), - printer_->form_printer); - fl_addto_tabfolder(dialog_->tabfolder_prefs, - _("Paths"), - paths_->form_paths); - - fl_set_form_atclose(dialog_->form_preferences, - C_FormPreferencesWMHideCB, 0); - - // deactivate the various browse buttons because they - // currently aren't implemented - fl_deactivate_object(bind_->button_bind_file_browse); + // deactivate the browse buttons because they aren't implemented fl_deactivate_object(paths_->button_document_browse); fl_deactivate_object(paths_->button_template_browse); fl_deactivate_object(paths_->button_temp_dir_browse); fl_deactivate_object(paths_->button_lastfiles_browse); fl_deactivate_object(paths_->button_backup_path_browse); - fl_set_object_lcol(bind_->button_bind_file_browse, FL_INACTIVE); + fl_deactivate_object(paths_->button_serverpipe_browse); fl_set_object_lcol(paths_->button_document_browse, FL_INACTIVE); fl_set_object_lcol(paths_->button_template_browse, FL_INACTIVE); fl_set_object_lcol(paths_->button_temp_dir_browse, FL_INACTIVE); fl_set_object_lcol(paths_->button_lastfiles_browse, FL_INACTIVE); fl_set_object_lcol(paths_->button_backup_path_browse, FL_INACTIVE); + fl_set_object_lcol(paths_->button_serverpipe_browse, FL_INACTIVE); + + // set up the feedback mechanism + fl_addto_form(paths_->form); + + setPostHandler( paths_->input_default_path ); + setPostHandler( paths_->button_document_browse ); + setPostHandler( paths_->counter_lastfiles ); + setPostHandler( paths_->input_template_path ); + setPostHandler( paths_->button_template_browse ); + setPostHandler( paths_->check_last_files ); + setPostHandler( paths_->button_temp_dir_browse ); + setPostHandler( paths_->input_lastfiles ); + setPostHandler( paths_->button_lastfiles_browse ); + setPostHandler( paths_->check_make_backups ); + setPostHandler( paths_->input_backup_path ); + setPostHandler( paths_->button_backup_path_browse ); + setPostHandler( paths_->input_serverpipe ); + setPostHandler( paths_->button_serverpipe_browse ); + setPostHandler( paths_->input_temp_dir ); + setPostHandler( paths_->check_use_temp_dir ); + + fl_end_form(); +} + + +void FormPreferences::feedbackPaths( FL_OBJECT const * const ob ) +{ + string str; + if( ob == paths_->input_default_path ) + str = lyxrc.getFeedback( LyXRC::RC_DOCUMENTPATH ); + else if ( ob == paths_->input_template_path ) + str = lyxrc.getFeedback( LyXRC::RC_TEMPLATEPATH ); + else if ( ob == paths_->check_use_temp_dir ) + str = lyxrc.getFeedback( LyXRC::RC_USETEMPDIR ); + else if ( ob == paths_->input_temp_dir ) + str = lyxrc.getFeedback( LyXRC::RC_TEMPDIRPATH ); + else if ( ob == paths_->check_last_files ) + str = lyxrc.getFeedback( LyXRC::RC_CHECKLASTFILES ); + else if ( ob == paths_->input_lastfiles ) + str = lyxrc.getFeedback( LyXRC::RC_LASTFILES ); + else if ( ob == paths_->counter_lastfiles ) + str = lyxrc.getFeedback( LyXRC::RC_NUMLASTFILES ); + else if ( ob == paths_->check_make_backups ) + str = lyxrc.getFeedback( LyXRC::RC_MAKE_BACKUP ); + else if ( ob == paths_->input_backup_path ) + str = lyxrc.getFeedback( LyXRC::RC_BACKUPDIR_PATH ); + else if ( ob == paths_->input_serverpipe ) + str = lyxrc.getFeedback( LyXRC::RC_SERVERPIPE ); + + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); } -void FormPreferences::show() -{ - if (!dialog_) { - build(); +bool FormPreferences::inputPaths( FL_OBJECT const * const ob ) +{ + bool activate = true; + + if( !ob || ob == paths_->check_use_temp_dir ) { + if( fl_get_button(paths_->check_use_temp_dir) ) { + fl_activate_object(paths_->input_temp_dir); + fl_set_object_lcol(paths_->input_temp_dir, + FL_BLACK); + } else { + fl_deactivate_object(paths_->input_temp_dir); + fl_set_object_lcol(paths_->input_temp_dir, + FL_INACTIVE); + } + } + + if( !ob || ob == paths_->check_last_files ) { + if( fl_get_button(paths_->check_last_files) ) { + fl_activate_object(paths_->input_lastfiles); + fl_set_object_lcol(paths_->input_lastfiles, + FL_BLACK); + } else { + fl_deactivate_object(paths_->input_lastfiles); + fl_set_object_lcol(paths_->input_lastfiles, + FL_INACTIVE); + } + } + + if( !ob || ob == paths_->check_make_backups ) { + if( fl_get_button(paths_->check_make_backups) ) { + fl_activate_object(paths_->input_backup_path); + fl_set_object_lcol(paths_->input_backup_path, + FL_BLACK); + } else { + fl_deactivate_object(paths_->input_backup_path); + fl_set_object_lcol(paths_->input_backup_path, + FL_INACTIVE); + } + } + + if( !ob || ob == paths_->input_default_path ) { + string name = fl_get_input(paths_->input_default_path); + if( !WriteableDir(name) ) + return false; } - update(); // make sure its up-to-date - if (dialog_->form_preferences->visible) { - fl_raise_form(dialog_->form_preferences); - } else { - status = DIALOG_UNMODIFIED; - fl_deactivate_object(dialog_->button_ok); - fl_deactivate_object(dialog_->button_apply); - fl_set_object_lcol(dialog_->button_ok, FL_INACTIVE); - fl_set_object_lcol(dialog_->button_apply, FL_INACTIVE); + if( !ob || ob == paths_->input_template_path ) { + string name = fl_get_input(paths_->input_template_path); + if( !ReadableDir(name) ) + return false; + } - fl_show_form(dialog_->form_preferences, - FL_PLACE_MOUSE | FL_FREE_SIZE, - FL_FULLBORDER, - _("Preferences")); + if( !ob || ob == paths_->input_temp_dir ) { + string name = fl_get_input(paths_->input_temp_dir); + if( fl_get_button(paths_->check_make_backups) + && !name.empty() + && !WriteableDir(name) ) + return false; + } + + if( !ob || ob == paths_->input_backup_path ) { + string name = fl_get_input(paths_->input_backup_path); + if( fl_get_button(paths_->check_make_backups) + && !name.empty() + && !WriteableDir(name) ) + return false; } -} + if( !ob || ob == paths_->input_lastfiles ) { + string name = fl_get_input(paths_->input_lastfiles); + if( fl_get_button(paths_->check_last_files) + && !name.empty() + && !WriteableFile(name) ) + return false; + } -void FormPreferences::hide() -{ - if (dialog_ - && dialog_->form_preferences - && dialog_->form_preferences->visible) { - fl_hide_form(dialog_->form_preferences); + if( !ob || ob == paths_->input_serverpipe ) { + string name = fl_get_input(paths_->input_serverpipe); + if( !name.empty() ) { + if( !WriteableFile(name, ".in") ) + return false; + if( !WriteableFile(name, ".out") ) + return false; + } } + + return activate; } -void FormPreferences::apply() +void FormPreferences::updatePaths() { - // set the new lyxrc entries - // many of these need to trigger other functions when the assignment - // is made. For example, screen zoom and font types. These could be - // handled either by signals/slots in lyxrc or just directly call the - // associated functions here. + fl_set_input(paths_->input_default_path, + lyxrc.document_path.c_str()); + fl_set_input(paths_->input_template_path, + lyxrc.template_path.c_str()); - // Bind tab - lyxrc.bind_file = fl_get_input(bind_->input_bind); - // Misc tab - lyxrc.show_banner = fl_get_button(misc_->check_banner); - lyxrc.auto_region_delete = fl_get_button(misc_-> - check_auto_region_delete); - lyxrc.exit_confirmation = fl_get_button(misc_->check_exit_confirm); - lyxrc.display_shortcuts = - fl_get_button(misc_->check_display_shortcuts); - lyxrc.autosave = static_cast - (fl_get_counter_value(misc_->counter_autosave)); - lyxrc.ascii_linelen = static_cast - (fl_get_counter_value(misc_->counter_line_len)); - // Screen fonts - lyxrc.roman_font_name = fl_get_input(screen_fonts_->input_roman); - lyxrc.sans_font_name = fl_get_input(screen_fonts_->input_sans); - lyxrc.typewriter_font_name = fl_get_input(screen_fonts_-> - input_typewriter); - lyxrc.font_norm = fl_get_input(screen_fonts_->input_encoding); - lyxrc.use_scalable_fonts = - fl_get_button(screen_fonts_->check_scalable); - lyxrc.zoom = static_cast - (fl_get_counter_value(screen_fonts_->counter_zoom)); - lyxrc.font_sizes[LyXFont::SIZE_TINY] = - strToDbl(fl_get_input(screen_fonts_->input_tiny)); - lyxrc.font_sizes[LyXFont::SIZE_SCRIPT] = - strToDbl(fl_get_input(screen_fonts_->input_script)); - lyxrc.font_sizes[LyXFont::SIZE_FOOTNOTE] = - strToDbl(fl_get_input(screen_fonts_->input_footnote)); - lyxrc.font_sizes[LyXFont::SIZE_SMALL] = - strToDbl(fl_get_input(screen_fonts_->input_small)); - lyxrc.font_sizes[LyXFont::SIZE_NORMAL] = - strToDbl(fl_get_input(screen_fonts_->input_normal)); - lyxrc.font_sizes[LyXFont::SIZE_LARGE] = - strToDbl(fl_get_input(screen_fonts_->input_large)); - lyxrc.font_sizes[LyXFont::SIZE_LARGER] = - strToDbl(fl_get_input(screen_fonts_->input_larger)); - lyxrc.font_sizes[LyXFont::SIZE_LARGEST] = - strToDbl(fl_get_input(screen_fonts_->input_largest)); - lyxrc.font_sizes[LyXFont::SIZE_HUGE] = - strToDbl(fl_get_input(screen_fonts_->input_huge)); - lyxrc.font_sizes[LyXFont::SIZE_HUGER] = - strToDbl(fl_get_input(screen_fonts_->input_huger)); - // interface fonts - lyxrc.popup_font_name = - fl_get_input(interface_fonts_->input_popup_font); - lyxrc.menu_font_name = fl_get_input(interface_fonts_->input_menu_font); - lyxrc.font_norm_menu = fl_get_input(interface_fonts_->input_encoding); - // printer + string str = string(); + if( lyxrc.make_backup ) str = lyxrc.backupdir_path; + + fl_set_button(paths_->check_make_backups, + lyxrc.make_backup); + fl_set_input(paths_->input_backup_path, str.c_str()); + + str.erase(); + if( lyxrc.use_tempdir ) str = lyxrc.tempdir_path; + + fl_set_button(paths_->check_use_temp_dir, + lyxrc.use_tempdir); + fl_set_input(paths_->input_temp_dir, str.c_str()); + + str.erase(); + if( lyxrc.check_lastfiles ) str = lyxrc.lastfiles; + + fl_set_button(paths_->check_last_files, + lyxrc.check_lastfiles); + fl_set_input(paths_->input_lastfiles, str.c_str()); + fl_set_counter_value(paths_->counter_lastfiles, + lyxrc.num_lastfiles); + + fl_set_input(paths_->input_serverpipe, lyxrc.lyxpipes.c_str()); + + // Activate/Deactivate the input fields dependent on the state of the + // buttons. + inputPaths( 0 ); +} + + +void FormPreferences::applyPrinter() +{ lyxrc.print_adapt_output = fl_get_button(printer_->check_adapt_output); lyxrc.print_command = fl_get_input(printer_->input_command); lyxrc.print_pagerange_flag = fl_get_input(printer_->input_page_range); @@ -273,176 +1072,351 @@ void FormPreferences::apply() lyxrc.print_paper_dimension_flag = fl_get_input(printer_->input_paper_size); lyxrc.printer = fl_get_input(printer_->input_name); - // paths - lyxrc.document_path = fl_get_input(paths_->input_default_path); - lyxrc.template_path = fl_get_input(paths_->input_template_path); - lyxrc.tempdir_path = fl_get_input(paths_->input_temp_dir); - lyxrc.lastfiles = fl_get_input(paths_->input_lastfiles); - lyxrc.backupdir_path = fl_get_input(paths_->input_backup_path); - lyxrc.use_tempdir = fl_get_button(paths_->check_use_temp_dir); - lyxrc.check_lastfiles = fl_get_button(paths_->check_last_files); - lyxrc.make_backup = fl_get_button(paths_->check_make_backups); - lyxrc.num_lastfiles = static_cast - (fl_get_counter_value(paths_->counter_lastfiles)); } -void FormPreferences::update() +void FormPreferences::feedbackPrinter( FL_OBJECT const * const ob ) { - if (dialog_) { - // read lyxrc entries - // Bind tab - fl_set_input(bind_->input_bind, lyxrc.bind_file.c_str()); - // Misc tab - fl_set_button(misc_->check_banner, - lyxrc.show_banner); - fl_set_button(misc_->check_auto_region_delete, - lyxrc.auto_region_delete); - fl_set_button(misc_->check_exit_confirm, - lyxrc.exit_confirmation); - fl_set_button(misc_->check_display_shortcuts, - lyxrc.display_shortcuts); - fl_set_counter_value(misc_->counter_autosave, - lyxrc.autosave); - fl_set_counter_value(misc_->counter_line_len, - lyxrc.ascii_linelen); - // Screen fonts - fl_set_input(screen_fonts_->input_roman, - lyxrc.roman_font_name.c_str()); - fl_set_input(screen_fonts_->input_sans, - lyxrc.sans_font_name.c_str()); - fl_set_input(screen_fonts_->input_typewriter, - lyxrc.typewriter_font_name.c_str()); - fl_set_input(screen_fonts_->input_encoding, - lyxrc.font_norm.c_str()); - fl_set_button(screen_fonts_->check_scalable, - lyxrc.use_scalable_fonts); - fl_set_counter_value(screen_fonts_->counter_zoom, - lyxrc.zoom); - fl_set_input(screen_fonts_->input_tiny, - tostr(lyxrc.font_sizes[LyXFont::SIZE_TINY]).c_str()); - fl_set_input(screen_fonts_->input_script, - tostr(lyxrc.font_sizes[LyXFont::SIZE_SCRIPT]).c_str()); - fl_set_input(screen_fonts_->input_footnote, - tostr(lyxrc.font_sizes[LyXFont::SIZE_FOOTNOTE]).c_str()); - fl_set_input(screen_fonts_->input_small, - tostr(lyxrc.font_sizes[LyXFont::SIZE_SMALL]).c_str()); - fl_set_input(screen_fonts_->input_normal, - tostr(lyxrc.font_sizes[LyXFont::SIZE_NORMAL]).c_str()); - fl_set_input(screen_fonts_->input_large, - tostr(lyxrc.font_sizes[LyXFont::SIZE_LARGE]).c_str()); - fl_set_input(screen_fonts_->input_larger, - tostr(lyxrc.font_sizes[LyXFont::SIZE_LARGER]).c_str()); - fl_set_input(screen_fonts_->input_largest, - tostr(lyxrc.font_sizes[LyXFont::SIZE_LARGEST]).c_str()); - fl_set_input(screen_fonts_->input_huge, - tostr(lyxrc.font_sizes[LyXFont::SIZE_HUGE]).c_str()); - fl_set_input(screen_fonts_->input_huger, - tostr(lyxrc.font_sizes[LyXFont::SIZE_HUGER]).c_str()); - // interface fonts - fl_set_input(interface_fonts_->input_popup_font, - lyxrc.popup_font_name.c_str()); - fl_set_input(interface_fonts_->input_menu_font, - lyxrc.menu_font_name.c_str()); - fl_set_input(interface_fonts_->input_encoding, - lyxrc.font_norm_menu.c_str()); - // printer - fl_set_button(printer_->check_adapt_output, - lyxrc.print_adapt_output); - fl_set_input(printer_->input_command, - lyxrc.print_command.c_str()); - fl_set_input(printer_->input_page_range, - lyxrc.print_pagerange_flag.c_str()); - fl_set_input(printer_->input_copies, - lyxrc.print_copies_flag.c_str()); - fl_set_input(printer_->input_reverse, - lyxrc.print_reverse_flag.c_str()); - fl_set_input(printer_->input_to_printer, - lyxrc.print_to_printer.c_str()); - fl_set_input(printer_->input_file_extension, - lyxrc.print_file_extension.c_str()); - fl_set_input(printer_->input_spool_command, - lyxrc.print_spool_command.c_str()); - fl_set_input(printer_->input_paper_type, - lyxrc.print_paper_flag.c_str()); - fl_set_input(printer_->input_even_pages, - lyxrc.print_evenpage_flag.c_str()); - fl_set_input(printer_->input_odd_pages, - lyxrc.print_oddpage_flag.c_str()); - fl_set_input(printer_->input_collated, - lyxrc.print_collcopies_flag.c_str()); - fl_set_input(printer_->input_landscape, - lyxrc.print_landscape_flag.c_str()); - fl_set_input(printer_->input_to_file, - lyxrc.print_to_file.c_str()); - fl_set_input(printer_->input_extra_options, - lyxrc.print_extra_options.c_str()); - fl_set_input(printer_->input_spool_prefix, - lyxrc.print_spool_printerprefix.c_str()); - fl_set_input(printer_->input_paper_size, - lyxrc.print_paper_dimension_flag.c_str()); - fl_set_input(printer_->input_name, - lyxrc.printer.c_str()); - // paths - fl_set_input(paths_->input_default_path, - lyxrc.document_path.c_str()); - fl_set_input(paths_->input_template_path, - lyxrc.template_path.c_str()); - fl_set_input(paths_->input_temp_dir, - lyxrc.tempdir_path.c_str()); - fl_set_input(paths_->input_lastfiles, - lyxrc.lastfiles.c_str()); - fl_set_input(paths_->input_backup_path, - lyxrc.backupdir_path.c_str()); - fl_set_button(paths_->check_use_temp_dir, - lyxrc.use_tempdir); - fl_set_button(paths_->check_last_files, - lyxrc.check_lastfiles); - fl_set_button(paths_->check_make_backups, - lyxrc.make_backup); - fl_set_counter_value(paths_->counter_lastfiles, - lyxrc.num_lastfiles); - } -} - - -void FormPreferences::input() + string str; + + if( ob == printer_->input_command ) + str = lyxrc.getFeedback( LyXRC::RC_PRINT_COMMAND ); + else if( ob == printer_->check_adapt_output ) + str = lyxrc.getFeedback( LyXRC::RC_PRINT_ADAPTOUTPUT ); + else if( ob == printer_->input_to_printer ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTTOPRINTER ); + else if( ob == printer_->input_to_file ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTTOFILE ); + else if( ob == printer_->input_file_extension ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTFILEEXTENSION ); + else if( ob == printer_->input_extra_options ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTEXSTRAOPTIONS ); + else if( ob == printer_->input_spool_command ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTSPOOL_COMMAND ); + else if( ob == printer_->input_spool_prefix ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTSPOOL_PRINTERPREFIX ); + else if( ob == printer_->input_name ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTER ); + else if( ob == printer_->input_even_pages ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTEVENPAGEFLAG ); + else if( ob == printer_->input_odd_pages ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTODDPAGEFLAG ); + else if( ob == printer_->input_page_range ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTPAGERANGEFLAG ); + else if( ob == printer_->input_reverse ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTREVERSEFLAG ); + else if( ob == printer_->input_landscape ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTLANDSCAPEFLAG ); + else if( ob == printer_->input_copies ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTCOLLCOPIESFLAG ); + else if( ob == printer_->input_collated ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTCOPIESFLAG ); + else if( ob == printer_->input_paper_type ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTPAPERFLAG ); + else if( ob == printer_->input_paper_size ) + str = lyxrc.getFeedback( LyXRC::RC_PRINTPAPERDIMENSIONFLAG ); + + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); +} + + +void FormPreferences::buildPrinter() { - bool activate = true; - // - // whatever checks you need to ensure the user hasn't entered - // some totally ridiculous value somewhere. Change activate to suit. - // - // Examples: - // paths -- all dirs in the path should exist, be writable & absolute - if (!AbsolutePath(fl_get_input(paths_->input_default_path)) - || 1 != IsDirWriteable(fl_get_input(paths_->input_default_path)) - || !AbsolutePath(fl_get_input(paths_->input_template_path)) - || 1 != IsDirWriteable(fl_get_input(paths_->input_template_path)) - // lastfiles: exists && writeable || non-existent && isn't a dir - // NOTE: assumes IsFileWriteable == -1 means non-existent hence - // the extra check to see if its a directory - || !AbsolutePath(fl_get_input(paths_->input_lastfiles)) - || 1 != IsDirWriteable(OnlyPath(fl_get_input(paths_-> - input_lastfiles))) - || 0 == IsFileWriteable(OnlyPath(fl_get_input(paths_-> - input_lastfiles))) - || FileInfo(fl_get_input(paths_->input_lastfiles)).isDir() - // tmpdir: only check if we are using it - || (fl_get_button(paths_->check_use_temp_dir) - && (1 != IsDirWriteable(fl_get_input(paths_->input_temp_dir)) - || !AbsolutePath(fl_get_input(paths_->input_temp_dir)))) - // backupdir: can safely be left empty - || (fl_get_button(paths_->check_make_backups) - && (!string(fl_get_input(paths_->input_backup_path)).empty() - && (1 != IsDirWriteable(fl_get_input(paths_-> - input_backup_path)) - || !AbsolutePath(fl_get_input(paths_-> - input_backup_path)))))) { - activate = false; + printer_ = build_printer(); + + fl_set_input_return(printer_->input_command, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_page_range, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_copies, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_reverse, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_to_printer, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_file_extension, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_spool_command, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_paper_type, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_even_pages, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_odd_pages, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_collated, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_landscape, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_to_file, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_extra_options, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_spool_prefix, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_paper_size, FL_RETURN_CHANGED); + fl_set_input_return(printer_->input_name, FL_RETURN_CHANGED); + + // set up the feedback mechanism + fl_addto_form(printer_->form); + + setPostHandler( printer_->input_command ); + setPostHandler( printer_->input_page_range ); + setPostHandler( printer_->input_copies ); + setPostHandler( printer_->input_reverse ); + setPostHandler( printer_->input_to_printer ); + setPostHandler( printer_->input_file_extension ); + setPostHandler( printer_->input_spool_command ); + setPostHandler( printer_->input_paper_type ); + setPostHandler( printer_->input_even_pages ); + setPostHandler( printer_->input_odd_pages ); + setPostHandler( printer_->input_collated ); + setPostHandler( printer_->input_landscape ); + setPostHandler( printer_->input_to_file ); + setPostHandler( printer_->input_extra_options ); + setPostHandler( printer_->input_spool_prefix ); + setPostHandler( printer_->input_paper_size ); + setPostHandler( printer_->input_name ); + setPostHandler( printer_->check_adapt_output ); + + fl_end_form(); +} + + +void FormPreferences::updatePrinter() +{ + fl_set_button(printer_->check_adapt_output, + lyxrc.print_adapt_output); + fl_set_input(printer_->input_command, + lyxrc.print_command.c_str()); + fl_set_input(printer_->input_page_range, + lyxrc.print_pagerange_flag.c_str()); + fl_set_input(printer_->input_copies, + lyxrc.print_copies_flag.c_str()); + fl_set_input(printer_->input_reverse, + lyxrc.print_reverse_flag.c_str()); + fl_set_input(printer_->input_to_printer, + lyxrc.print_to_printer.c_str()); + fl_set_input(printer_->input_file_extension, + lyxrc.print_file_extension.c_str()); + fl_set_input(printer_->input_spool_command, + lyxrc.print_spool_command.c_str()); + fl_set_input(printer_->input_paper_type, + lyxrc.print_paper_flag.c_str()); + fl_set_input(printer_->input_even_pages, + lyxrc.print_evenpage_flag.c_str()); + fl_set_input(printer_->input_odd_pages, + lyxrc.print_oddpage_flag.c_str()); + fl_set_input(printer_->input_collated, + lyxrc.print_collcopies_flag.c_str()); + fl_set_input(printer_->input_landscape, + lyxrc.print_landscape_flag.c_str()); + fl_set_input(printer_->input_to_file, + lyxrc.print_to_file.c_str()); + fl_set_input(printer_->input_extra_options, + lyxrc.print_extra_options.c_str()); + fl_set_input(printer_->input_spool_prefix, + lyxrc.print_spool_printerprefix.c_str()); + fl_set_input(printer_->input_paper_size, + lyxrc.print_paper_dimension_flag.c_str()); + fl_set_input(printer_->input_name, + lyxrc.printer.c_str()); +} + + +void FormPreferences::applyScreenFonts() +{ + bool changed = false; + + string str = fl_get_input(screen_fonts_->input_roman); + if( lyxrc.roman_font_name != str ) { + changed = true; + lyxrc.roman_font_name = str; + } + + str = fl_get_input(screen_fonts_->input_sans); + if( lyxrc.sans_font_name != str ) { + changed = true; + lyxrc.sans_font_name = str; + } + + str = fl_get_input(screen_fonts_->input_typewriter); + if( lyxrc.typewriter_font_name != str ) { + changed = true; + lyxrc.typewriter_font_name = str; + } + + str = fl_get_input(screen_fonts_->input_screen_encoding); + if( lyxrc.font_norm != str ) { + changed = true; + lyxrc.font_norm = str; + } + + bool button = fl_get_button(screen_fonts_->check_scalable); + if( lyxrc.use_scalable_fonts != button ) { + changed = true; + lyxrc.use_scalable_fonts = button; + } + + unsigned int ivalue = static_cast + (fl_get_counter_value(screen_fonts_->counter_zoom)); + if( lyxrc.zoom != ivalue) { + changed = true; + lyxrc.zoom = ivalue; + } + + ivalue = static_cast + (fl_get_counter_value(screen_fonts_->counter_dpi)); + if (lyxrc.dpi != ivalue) { + changed = true; + lyxrc.dpi = ivalue; + } + + double dvalue = strToDbl(fl_get_input(screen_fonts_->input_tiny)); + if( lyxrc.font_sizes[LyXFont::SIZE_TINY] != dvalue ) { + changed = true; + lyxrc.font_sizes[LyXFont::SIZE_TINY] = dvalue; + } + + dvalue = strToDbl(fl_get_input(screen_fonts_->input_script)); + if( lyxrc.font_sizes[LyXFont::SIZE_SCRIPT] != dvalue ) { + changed = true; + lyxrc.font_sizes[LyXFont::SIZE_SCRIPT] = dvalue; + } + + dvalue = strToDbl(fl_get_input(screen_fonts_->input_footnote)); + if( lyxrc.font_sizes[LyXFont::SIZE_FOOTNOTE] != dvalue ) { + changed = true; + lyxrc.font_sizes[LyXFont::SIZE_FOOTNOTE] = dvalue; + } + + dvalue = strToDbl(fl_get_input(screen_fonts_->input_small)); + if( lyxrc.font_sizes[LyXFont::SIZE_SMALL] != dvalue ) { + changed = true; + lyxrc.font_sizes[LyXFont::SIZE_SMALL] = dvalue; + } + + dvalue = strToDbl(fl_get_input(screen_fonts_->input_normal)); + if( lyxrc.font_sizes[LyXFont::SIZE_NORMAL] != dvalue ) { + changed = true; + lyxrc.font_sizes[LyXFont::SIZE_NORMAL] = dvalue; + } + + dvalue = strToDbl(fl_get_input(screen_fonts_->input_large)); + if( lyxrc.font_sizes[LyXFont::SIZE_LARGE] != dvalue ) { + changed = true; + lyxrc.font_sizes[LyXFont::SIZE_LARGE] = dvalue; + } + + dvalue = strToDbl(fl_get_input(screen_fonts_->input_larger)); + if( lyxrc.font_sizes[LyXFont::SIZE_LARGER] != dvalue ) { + changed = true; + lyxrc.font_sizes[LyXFont::SIZE_LARGER] = dvalue; + } + + dvalue = strToDbl(fl_get_input(screen_fonts_->input_largest)); + if( lyxrc.font_sizes[LyXFont::SIZE_LARGEST] != dvalue ) { + changed = true; + lyxrc.font_sizes[LyXFont::SIZE_LARGEST] = dvalue; + } + + dvalue = strToDbl(fl_get_input(screen_fonts_->input_huge)); + if( lyxrc.font_sizes[LyXFont::SIZE_HUGE] != dvalue ) { + changed = true; + lyxrc.font_sizes[LyXFont::SIZE_HUGE] = dvalue; + } + + dvalue = strToDbl(fl_get_input(screen_fonts_->input_huger)); + if( lyxrc.font_sizes[LyXFont::SIZE_HUGER] != dvalue ) { + changed = true; + lyxrc.font_sizes[LyXFont::SIZE_HUGER] = dvalue; + } + + if( changed ) { + // Now update the buffers + // Can anything below here affect the redraw process? + lv_->getLyXFunc()->Dispatch(LFUN_SCREEN_FONT_UPDATE); } +} + + +void FormPreferences::buildScreenFonts() +{ + screen_fonts_ = build_screen_fonts(); + + fl_set_input_return(screen_fonts_->input_roman, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_sans, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_typewriter, + FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_screen_encoding, + FL_RETURN_CHANGED); + fl_set_counter_return(screen_fonts_->counter_zoom, FL_RETURN_CHANGED); + fl_set_counter_return(screen_fonts_->counter_dpi, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_tiny, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_script, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_footnote, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_small, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_normal, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_large, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_larger, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_largest, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_huge, FL_RETURN_CHANGED); + fl_set_input_return(screen_fonts_->input_huger, FL_RETURN_CHANGED); + + // set up the feedback mechanism + fl_addto_form(screen_fonts_->form); + + setPostHandler( screen_fonts_->input_roman ); + setPostHandler( screen_fonts_->input_sans ); + setPostHandler( screen_fonts_->input_typewriter ); + setPostHandler( screen_fonts_->counter_zoom ); + setPostHandler( screen_fonts_->counter_dpi ); + setPostHandler( screen_fonts_->check_scalable ); + setPostHandler( screen_fonts_->input_screen_encoding ); + setPostHandler( screen_fonts_->input_tiny ); + setPostHandler( screen_fonts_->input_script ); + setPostHandler( screen_fonts_->input_footnote ); + setPostHandler( screen_fonts_->input_small ); + setPostHandler( screen_fonts_->input_large ); + setPostHandler( screen_fonts_->input_larger ); + setPostHandler( screen_fonts_->input_largest ); + setPostHandler( screen_fonts_->input_normal ); + setPostHandler( screen_fonts_->input_huge ); + setPostHandler( screen_fonts_->input_huger ); + + fl_end_form(); +} + + +void FormPreferences::feedbackScreenFonts(FL_OBJECT const * const ob ) +{ + string str; + + if( ob == screen_fonts_->input_roman ) + str = lyxrc.getFeedback( LyXRC::RC_SCREEN_FONT_ROMAN ); + else if( ob == screen_fonts_->input_sans ) + str = lyxrc.getFeedback( LyXRC::RC_SCREEN_FONT_SANS ); + else if( ob == screen_fonts_->input_typewriter ) + str = lyxrc.getFeedback( LyXRC::RC_SCREEN_FONT_TYPEWRITER ); + else if( ob == screen_fonts_->check_scalable ) + str = lyxrc.getFeedback( LyXRC::RC_SCREEN_FONT_SCALABLE ); + else if( ob == screen_fonts_->input_screen_encoding ) + str = lyxrc.getFeedback( LyXRC::RC_SCREEN_FONT_ENCODING ); + else if( ob == screen_fonts_->counter_zoom ) + str = lyxrc.getFeedback( LyXRC::RC_SCREEN_ZOOM ); + else if( ob == screen_fonts_->counter_dpi ) + str = lyxrc.getFeedback( LyXRC::RC_SCREEN_DPI ); + else if( ob == screen_fonts_->input_tiny + || ob == screen_fonts_->input_script + || ob == screen_fonts_->input_footnote + || ob == screen_fonts_->input_small + || ob == screen_fonts_->input_large + || ob == screen_fonts_->input_larger + || ob == screen_fonts_->input_larger + || ob == screen_fonts_->input_largest + || ob == screen_fonts_->input_normal + || ob == screen_fonts_->input_huge + || ob == screen_fonts_->input_huger ) + str = lyxrc.getFeedback( LyXRC::RC_SCREEN_FONT_SIZES ); - // fontsizes -- tiny < script < footnote etc. + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); +} + + +bool FormPreferences::inputScreenFonts() +{ + bool activate = true; + string str; + + // Make sure that all fonts all have positive entries + // Also note that an empty entry is returned as 0.0 by strToDbl if (0.0 >= strToDbl(fl_get_input(screen_fonts_->input_tiny)) || 0.0 >= strToDbl(fl_get_input(screen_fonts_->input_script)) || 0.0 >= strToDbl(fl_get_input(screen_fonts_->input_footnote)) @@ -453,9 +1427,10 @@ void FormPreferences::input() || 0.0 >= strToDbl(fl_get_input(screen_fonts_->input_largest)) || 0.0 >= strToDbl(fl_get_input(screen_fonts_->input_huge)) || 0.0 >= strToDbl(fl_get_input(screen_fonts_->input_huger))) { - // make sure they all have positive entries - // Also note that an empty entry is returned as 0.0 by strToDbl activate = false; + str = N_("WARNING! Fonts must be positive!"); + + // Fontsizes -- tiny < script < footnote etc. } else if (strToDbl(fl_get_input(screen_fonts_->input_tiny)) > strToDbl(fl_get_input(screen_fonts_->input_script)) || strToDbl(fl_get_input(screen_fonts_->input_script)) > @@ -475,79 +1450,472 @@ void FormPreferences::input() strToDbl(fl_get_input(screen_fonts_->input_huge)) > strToDbl(fl_get_input(screen_fonts_->input_huger))) { activate = false; + + str = N_("WARNING! Fonts must be input in the order tiny > script>\nfootnote > small > normal > large > larger > largest > huge > huger."); + } + + if( !activate ) { + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); + } + + return activate; +} + + +void FormPreferences::updateScreenFonts() +{ + fl_set_input(screen_fonts_->input_roman, + lyxrc.roman_font_name.c_str()); + fl_set_input(screen_fonts_->input_sans, + lyxrc.sans_font_name.c_str()); + fl_set_input(screen_fonts_->input_typewriter, + lyxrc.typewriter_font_name.c_str()); + fl_set_input(screen_fonts_->input_screen_encoding, + lyxrc.font_norm.c_str()); + fl_set_button(screen_fonts_->check_scalable, + lyxrc.use_scalable_fonts); + fl_set_counter_value(screen_fonts_->counter_zoom, lyxrc.zoom); + fl_set_counter_value(screen_fonts_->counter_dpi, lyxrc.dpi); + fl_set_input(screen_fonts_->input_tiny, + tostr(lyxrc.font_sizes[LyXFont::SIZE_TINY]).c_str()); + fl_set_input(screen_fonts_->input_script, + tostr(lyxrc.font_sizes[LyXFont::SIZE_SCRIPT]).c_str()); + fl_set_input(screen_fonts_->input_footnote, + tostr(lyxrc.font_sizes[LyXFont::SIZE_FOOTNOTE]).c_str()); + fl_set_input(screen_fonts_->input_small, + tostr(lyxrc.font_sizes[LyXFont::SIZE_SMALL]).c_str()); + fl_set_input(screen_fonts_->input_normal, + tostr(lyxrc.font_sizes[LyXFont::SIZE_NORMAL]).c_str()); + fl_set_input(screen_fonts_->input_large, + tostr(lyxrc.font_sizes[LyXFont::SIZE_LARGE]).c_str()); + fl_set_input(screen_fonts_->input_larger, + tostr(lyxrc.font_sizes[LyXFont::SIZE_LARGER]).c_str()); + fl_set_input(screen_fonts_->input_largest, + tostr(lyxrc.font_sizes[LyXFont::SIZE_LARGEST]).c_str()); + fl_set_input(screen_fonts_->input_huge, + tostr(lyxrc.font_sizes[LyXFont::SIZE_HUGE]).c_str()); + fl_set_input(screen_fonts_->input_huger, + tostr(lyxrc.font_sizes[LyXFont::SIZE_HUGER]).c_str()); +} + + +void FormPreferences::applySpellChecker() +{ + + string choice = "none"; + switch(fl_get_choice(spellchecker_->choice_spell_command)) { + case 1: + choice = "none"; + break; + case 2: + choice = "ispell"; + break; + case 3: + choice = "aspell"; + break; + default: + break; } + lyxrc.isp_command = choice; - // - // You can modify the dialog and still have the buttons disabled - status = DIALOG_MODIFIED; + // If spell checker == "none", all other input set to off. + if( fl_get_choice(spellchecker_->choice_spell_command) == 1 ) { + lyxrc.isp_use_alt_lang = false; + lyxrc.isp_alt_lang.erase(); - if (status == DIALOG_MODIFIED - && activate) { - fl_activate_object(dialog_->button_ok); - fl_activate_object(dialog_->button_apply); - fl_set_object_lcol(dialog_->button_ok, FL_BLACK); - fl_set_object_lcol(dialog_->button_apply, FL_BLACK); + lyxrc.isp_use_esc_chars = false; + lyxrc.isp_esc_chars.erase(); + + lyxrc.isp_use_pers_dict = false; + lyxrc.isp_pers_dict.erase(); + + lyxrc.isp_accept_compound = false; + lyxrc.isp_use_input_encoding = false; } else { - fl_deactivate_object(dialog_->button_ok); - fl_deactivate_object(dialog_->button_apply); - fl_set_object_lcol(dialog_->button_ok, FL_INACTIVE); - fl_set_object_lcol(dialog_->button_apply, FL_INACTIVE); + int button = fl_get_button(spellchecker_->check_alt_lang); + choice = fl_get_input(spellchecker_->input_alt_lang); + if( button && choice.empty() ) button = 0; + if( !button ) choice.erase(); + + lyxrc.isp_use_alt_lang = static_cast(button); + lyxrc.isp_alt_lang = choice; + + button = fl_get_button(spellchecker_->check_escape_chars); + choice = fl_get_input(spellchecker_->input_escape_chars); + if( button && choice.empty() ) button = 0; + if( !button ) choice.erase(); + + lyxrc.isp_use_esc_chars = static_cast(button); + lyxrc.isp_esc_chars = choice; + + button = fl_get_button(spellchecker_->check_personal_dict); + choice = fl_get_input(spellchecker_->input_personal_dict); + if( button && choice.empty() ) button = 0; + if( !button ) choice.erase(); + + lyxrc.isp_use_pers_dict = static_cast(button); + lyxrc.isp_pers_dict = choice; + + button = fl_get_button(spellchecker_->check_compound_words); + lyxrc.isp_accept_compound = static_cast(button); + + button = fl_get_button(spellchecker_->check_input_enc); + lyxrc.isp_use_input_encoding = static_cast(button); } + + // Reset view + updateSpellChecker(); +} + + +void FormPreferences::buildSpellchecker() +{ + spellchecker_ = build_spellchecker(); + + fl_addto_choice(spellchecker_->choice_spell_command, + _(" none | ispell | aspell ")); + fl_set_input_return(spellchecker_->input_alt_lang, + FL_RETURN_CHANGED); + fl_set_input_return(spellchecker_->input_escape_chars, + FL_RETURN_CHANGED); + fl_set_input_return(spellchecker_->input_personal_dict, + FL_RETURN_CHANGED); + + // deactivate the browse button because it isn't implemented + fl_deactivate_object(spellchecker_->button_personal_dict); + fl_set_object_lcol(spellchecker_->button_personal_dict, + FL_INACTIVE); + + // set up the feedback mechanism + fl_addto_form(spellchecker_->form); + + setPostHandler( spellchecker_->choice_spell_command ); + setPostHandler( spellchecker_->check_alt_lang ); + setPostHandler( spellchecker_->input_alt_lang ); + setPostHandler( spellchecker_->check_escape_chars ); + setPostHandler( spellchecker_->input_escape_chars ); + setPostHandler( spellchecker_->check_personal_dict ); + setPostHandler( spellchecker_->input_personal_dict ); + setPostHandler( spellchecker_->button_personal_dict ); + setPostHandler( spellchecker_->check_compound_words ); + setPostHandler( spellchecker_->check_input_enc ); + + fl_end_form(); +} + + +void FormPreferences::feedbackSpellChecker( FL_OBJECT const * const ob ) +{ + string str; + if( ob == spellchecker_->choice_spell_command ) + str = lyxrc.getFeedback( LyXRC::RC_SPELL_COMMAND ); + else if( ob == spellchecker_->check_alt_lang ) + str = lyxrc.getFeedback( LyXRC::RC_USE_ALT_LANG ); + else if( ob == spellchecker_->input_alt_lang ) + str = lyxrc.getFeedback( LyXRC::RC_ALT_LANG ); + else if( ob == spellchecker_->check_escape_chars ) + str = lyxrc.getFeedback( LyXRC::RC_USE_ESC_CHARS ); + else if( ob == spellchecker_->input_escape_chars ) + str = lyxrc.getFeedback( LyXRC::RC_ESC_CHARS ); + else if( ob == spellchecker_->check_personal_dict ) + str = lyxrc.getFeedback( LyXRC::RC_USE_PERS_DICT ); + else if( ob == spellchecker_->input_personal_dict ) + str = lyxrc.getFeedback( LyXRC::RC_PERS_DICT ); + else if( ob == spellchecker_->check_compound_words ) + str = lyxrc.getFeedback( LyXRC::RC_ACCEPT_COMPOUND ); + else if( ob == spellchecker_->check_input_enc ) + str = lyxrc.getFeedback( LyXRC::RC_USE_INP_ENC ); + + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); } -void FormPreferences::free() +bool FormPreferences::inputSpellChecker( FL_OBJECT const * const ob ) { - // we don't need to delete u and h here because - // hide() does that after disconnecting. - if (dialog_) { - if (dialog_->form_preferences - && dialog_->form_preferences->visible) { - hide(); + // Allow/dissallow input + + // If spell checker == "none", disable all input. + if( !ob || ob == spellchecker_->choice_spell_command ) { + if( fl_get_choice(spellchecker_->choice_spell_command) == 1 ) { + fl_deactivate_object( spellchecker_->check_alt_lang ); + fl_deactivate_object( spellchecker_->input_alt_lang ); + fl_deactivate_object( spellchecker_->check_escape_chars ); + fl_deactivate_object( spellchecker_->input_escape_chars ); + fl_deactivate_object( spellchecker_->check_personal_dict ); + fl_deactivate_object( spellchecker_->input_personal_dict ); + fl_deactivate_object( spellchecker_->check_compound_words ); + fl_deactivate_object( spellchecker_->check_input_enc ); + return true; + } else { + fl_activate_object( spellchecker_->check_alt_lang ); + fl_activate_object( spellchecker_->check_escape_chars ); + fl_activate_object( spellchecker_->check_personal_dict ); + fl_activate_object( spellchecker_->check_compound_words ); + fl_activate_object( spellchecker_->check_input_enc ); + } + } + + if( !ob || ob == spellchecker_->check_alt_lang ) { + if( fl_get_button(spellchecker_->check_alt_lang) ) { + fl_activate_object(spellchecker_->input_alt_lang); + fl_set_object_lcol(spellchecker_->input_alt_lang, + FL_BLACK); + } else { + fl_deactivate_object(spellchecker_->input_alt_lang); + fl_set_object_lcol(spellchecker_->input_alt_lang, + FL_INACTIVE); + } + } + + if( !ob || ob == spellchecker_->check_escape_chars ) { + if( fl_get_button(spellchecker_->check_escape_chars) ) { + fl_activate_object(spellchecker_->input_escape_chars); + fl_set_object_lcol(spellchecker_->input_escape_chars, + FL_BLACK); + } else { + fl_deactivate_object(spellchecker_->input_escape_chars); + fl_set_object_lcol(spellchecker_->input_escape_chars, + FL_INACTIVE); + } + } + + if( !ob || ob == spellchecker_->check_personal_dict ) { + if( fl_get_button(spellchecker_->check_personal_dict) ) { + fl_activate_object(spellchecker_->input_personal_dict); + fl_set_object_lcol(spellchecker_->input_personal_dict, + FL_BLACK); + } else { + fl_deactivate_object(spellchecker_->input_personal_dict); + fl_set_object_lcol(spellchecker_->input_personal_dict, + FL_INACTIVE); } - fl_free_form(dialog_->form_preferences); - delete dialog_; - dialog_ = 0; } + + return true; // all input is valid! +} + + +void FormPreferences::updateSpellChecker() +{ + int choice = 1; + if( lyxrc.isp_command == "none" ) + choice = 1; + else if( lyxrc.isp_command == "ispell" ) + choice = 2; + else if( lyxrc.isp_command == "aspell" ) + choice = 3; + fl_set_choice(spellchecker_->choice_spell_command, choice); + + string str = string(); + if( lyxrc.isp_use_alt_lang ) str = lyxrc.isp_alt_lang; + + fl_set_button(spellchecker_->check_alt_lang, + lyxrc.isp_use_alt_lang); + fl_set_input(spellchecker_->input_alt_lang, str.c_str()); + + str.erase(); + if( lyxrc.isp_use_esc_chars ) str = lyxrc.isp_esc_chars; + + fl_set_button(spellchecker_->check_escape_chars, + lyxrc.isp_use_esc_chars); + fl_set_input(spellchecker_->input_escape_chars, str.c_str()); + + str.erase(); + if( lyxrc.isp_use_pers_dict ) str = lyxrc.isp_pers_dict; + + fl_set_button(spellchecker_->check_personal_dict, + lyxrc.isp_use_pers_dict); + fl_set_input(spellchecker_->input_personal_dict, str.c_str()); + + fl_set_button(spellchecker_->check_compound_words, + lyxrc.isp_accept_compound); + fl_set_button(spellchecker_->check_input_enc, + lyxrc.isp_use_input_encoding); + + // Activate/Deactivate the input fields dependent on the state of the + // buttons. + inputSpellChecker( 0 ); +} + + +bool FormPreferences::WriteableDir( string const & name ) const +{ + bool success = true; + string str; + + if( !AbsolutePath(name) ) { + success = false; + str = N_("WARNING! The absolute path is required."); + } + + FileInfo tp(name); + if( success && !tp.isDir() ) { + success = false; + str = N_("WARNING! Directory does not exist."); + } + + if( success && !tp.writable() ) { + success = false; + str = N_("WARNING! Cannot write to this directory."); + } + + if( !success ) { + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); + } + + return success; } -int FormPreferences::WMHideCB(FL_FORM * form, void *) +bool FormPreferences::ReadableDir( string const & name ) const { - // Ensure that the signals (u and h) are disconnected even if the - // window manager is used to close the dialog. - FormPreferences * pre = static_cast(form->u_vdata); - pre->hide(); - return FL_CANCEL; + bool success = true; + string str; + + if( !AbsolutePath(name) ) { + success = false; + str = N_("WARNING! The absolute path is required."); + } + + FileInfo tp(name); + if( success && !tp.isDir() ) { + success = false; + str = N_("WARNING! Directory does not exist."); + } + + if( success && !tp.readable() ) { + success = false; + str = N_("WARNING! Cannot read this directory."); + } + + if( !success ) { + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); + } + + return success; } -void FormPreferences::OKCB(FL_OBJECT * ob, long) +bool FormPreferences::WriteableFile( string const & name, string const & suffix ) const { - FormPreferences * pre = static_cast(ob->form->u_vdata); - pre->apply(); - pre->hide(); + // A writeable file is either: + // * An existing file to which we have write access, or + // * A file that doesn't yet exist but that would exist in a writeable + // directory. + + bool success = true; + string str; + + if( name.empty() ) { + success = false; + str = N_("WARNING! No file input."); + } + + string dir = OnlyPath(name); + if( success && !AbsolutePath(dir) ) { + success = false; + str = N_("WARNING! The absolute path is required."); + } + + FileInfo d; + { + FileInfo d1(dir); + FileInfo d2(name); + if( d2.isDir() ) + d = d2; + else + d = d1; + } + + if( success && !d.isDir()) { + success = false; + str = N_("WARNING! Directory does not exist."); + } + + if( success && !d.writable() ) { + success = false; + str = N_("WARNING! Cannot write to this directory."); + } - pre->lv_->getLyXFunc()->Dispatch(LFUN_SAVEPREFERENCES); + FileInfo f(name+suffix); + if( success && (dir == name || f.isDir()) ) { + success = false; + str = N_("WARNING! A file is required, not a directory."); + } + + if( success && (f.exist() && !f.writable()) ) { + success = false; + str = N_("WARNING! Cannot write to this file."); + } + + if( !success ) { + fl_set_object_label(dialog_->text_warning, str.c_str()); + fl_set_object_lsize(dialog_->text_warning, FL_SMALL_SIZE); + } + + return success; +} + + +void FormPreferences::ComboLanguageCB(int, void * v, Combox * combox) +{ + FormPreferences * pre = static_cast(v); + pre->bc_.valid( pre->input( reinterpret_cast(combox), + FormPreferences::LANGUAGE ) ); } -void FormPreferences::ApplyCB(FL_OBJECT * ob, long) +// C functions for the timer callback used to give the user feedback +C_GENERICCB(FormPreferences, FeedbackCB) +extern "C" int C_FormPreferencesFeedbackPost(FL_OBJECT * ob, int event, + FL_Coord mx, FL_Coord my, + int key, void * xev) { - FormPreferences * pre = static_cast(ob->form->u_vdata); - pre->apply(); + FormPreferences * pre = + static_cast(ob->form->u_vdata); + return pre->FeedbackPost(ob, event, mx, my, key, xev); } -void FormPreferences::CancelCB(FL_OBJECT * ob, long) +void FormPreferences::FeedbackCB(FL_OBJECT *, long data) +{ + FL_OBJECT * ob = reinterpret_cast(data); + FormPreferences * pre = + static_cast(ob->form->u_vdata); + pre->feedback( ob ); +} + +// post_handler for feedback messages +int FormPreferences::FeedbackPost(FL_OBJECT *ob, int event, + FL_Coord, FL_Coord, int, void *) { - FormPreferences * pre = static_cast(ob->form->u_vdata); - pre->hide(); + FL_OBJECT * timer_feedback = reinterpret_cast(ob->u_cdata); + + // We do not test for empty help here, since this can never happen + if(event == FL_ENTER){ + fl_set_object_callback(timer_feedback, + C_FormPreferencesFeedbackCB, + reinterpret_cast(ob)); + fl_set_timer(timer_feedback, 0.5); + } + else if(event != FL_MOTION){ + fl_set_timer(timer_feedback, 0); + + FormPreferences * pre = + static_cast(ob->form->u_vdata); + + fl_set_object_label(pre->dialog_->text_warning, ""); + } + return 0; } -void FormPreferences::InputCB(FL_OBJECT * ob, long) +void FormPreferences::setPostHandler( FL_OBJECT * ob ) const { - FormPreferences * pre = static_cast(ob->form->u_vdata); - pre->input(); + ob->u_cdata = reinterpret_cast(dialog_->timer_feedback); + fl_set_object_posthandler(ob, C_FormPreferencesFeedbackPost); }