src/intl.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *           Copyright 1995 Matthias Ettrich
   7  *           Copyright 1995-2000 The LyX Team.
   8  *
   9  * ====================================================== */
  10
  11 /*
  12  *      International support for LyX
  13  */
  14
  15 #include <config.h>
  16
  17 #ifdef __GNUG__
  18 #pragma implementation
  19 #endif
  20
  21 #include FORMS_H_LOCATION
  22 #include "intl.h"
  23 #include "form1.h"
  24 #include "tex-strings.h"
  25 #include "combox.h"
  26 #include "lyx_gui_misc.h" // CancelCloseBoxCB
  27 #include "debug.h"
  28 #include "lyxrc.h"
  29
  30 #include "support/lstrings.h"
  31 #include "language.h"
  32 #include "frontends/Dialogs.h" // redrawGUI
  33
  34 using std::endl;
  35
  36 // a wrapper around the callback static member.
  37 extern "C" void C_Intl_DispatchCallback(FL_OBJECT * ob, long code);
  38
  39
  40 Intl::Intl()
  41         : prim_lang(lyxrc.primary_kbmap),
  42         sec_lang(lyxrc.secondary_kbmap)
  43 {
  44         keymapon = lyxrc.use_kbmap;
  45         chsetcode = 0;
  46         primarykeymap = false;
  47         curkeymap = 0;
  48         otherkeymap = 0;
  49         r_ = Dialogs::redrawGUI.connect(slot(this, &Intl::redraw));
  50 }
  51
  52
  53 Intl::~Intl()
  54 {
  55         fl_free(fd_form_keymap);
  56         r_.disconnect();
  57 }
  58
  59
  60 void Intl::redraw()
  61 {
  62         if (fd_form_keymap && fd_form_keymap->KeyMap->visible)
  63                 fl_redraw_form(fd_form_keymap->KeyMap);
  64 }
  65
  66
  67 int Intl::SetPrimary(string const & lang)
  68 {
  69         if (lyxerr.debugging(Debug::KBMAP))
  70                 lyxerr << "Primary: `" << lang << "'" << endl;
  71         return trans.SetPrimary(lang);
  72 }
  73
  74
  75 int Intl::SetSecondary(string const & lang)
  76 {
  77         if (lyxerr.debugging(Debug::KBMAP))
  78                 lyxerr << "Secondary: `" << lang << "'" << endl;
  79         return trans.SetSecondary(lang);
  80 }
  81
  82
  83 void Intl::update()
  84 {
  85         int off = 0;
  86         int prim = 0;
  87         int sec = 0;
  88
  89         if (!keymapon) {
  90                 off = 1;
  91         } else {
  92                 if (primarykeymap) {
  93                         prim = 1;
  94                 } else {
  95                         sec = 1;
  96                 }
  97         }
  98
  99         fl_set_button(fd_form_keymap->KeyOffBtn, off);
 100         fl_set_button(fd_form_keymap->KeyOnBtn, prim);
 101         fl_set_button(fd_form_keymap->KeyOnBtn2, sec);
 102 }
 103
 104
 105 void Intl::KeyMapOn(bool on)
 106         // turn on/off key mappings, status in keymapon
 107 {
 108         keymapon = on;
 109
 110         if (!fd_form_keymap) return;
 111
 112         fl_set_button(fd_form_keymap->KeyOffBtn, 0);
 113         fl_set_button(fd_form_keymap->KeyOnBtn, 0);
 114         fl_set_button(fd_form_keymap->KeyOnBtn2, 0);
 115
 116         if (on) {
 117                 if (primarykeymap) {
 118                         KeyMapPrim();
 119                 } else {
 120                         KeyMapSec();
 121                 }
 122         } else {
 123                 fl_set_button(fd_form_keymap->KeyOffBtn, 1);
 124                 fl_hide_object(fd_form_keymap->KeymapErr);
 125                 trans.DisableKeymap();
 126         }
 127 }
 128
 129
 130 void Intl::ToggleKeyMap()
 131 {
 132         if (keymapon && primarykeymap) {
 133                 KeyMapSec();
 134         } else if (keymapon) {
 135                 KeyMapOn(false);
 136         } else
 137                 KeyMapPrim();
 138 }
 139
 140
 141 void Intl::KeyMapPrim()
 142 {
 143         fl_set_button(fd_form_keymap->KeyOffBtn, 0);
 144         fl_set_button(fd_form_keymap->KeyOnBtn, 1);
 145         fl_set_button(fd_form_keymap->KeyOnBtn2, 0);
 146
 147         /* read text from choice */
 148         int const i = Language->get();
 149
 150         string p;
 151         if (i == otherkeymap)
 152                 p = fl_get_input(fd_form_keymap->OtherKeymap);
 153         else
 154                 p = Language->getline();
 155
 156         curkeymap = i;
 157
 158         if (p.empty() || trans.SetPrimary(p)) {
 159                 // error selecting keymap
 160                 fl_show_object(fd_form_keymap->KeymapErr);
 161                 update();
 162         } else {
 163                 // no error
 164                 trans.EnablePrimary();
 165                 keymapon = true;
 166                 primarykeymap = true;
 167                 fl_hide_object(fd_form_keymap->KeymapErr);
 168         }
 169 }
 170
 171
 172 void Intl::KeyMapSec()
 173 {
 174         fl_set_button(fd_form_keymap->KeyOffBtn, 0);
 175         fl_set_button(fd_form_keymap->KeyOnBtn, 0);
 176         fl_set_button(fd_form_keymap->KeyOnBtn2, 1);
 177
 178         // read text from choice
 179         int const i = Language2->get();
 180
 181         string p;
 182         if (i == otherkeymap)
 183                 p = fl_get_input(fd_form_keymap->OtherKeymap2);
 184         else
 185                 p = Language2->getline();
 186         curkeymap = i;
 187
 188         if (p.empty() || trans.SetSecondary(p)) {
 189                 // error selecting keymap
 190                 fl_show_object(fd_form_keymap->KeymapErr);
 191                 update();
 192         } else {
 193                 // no error
 194                 trans.EnableSecondary();
 195                 keymapon = true;
 196                 primarykeymap = false;
 197                 fl_hide_object(fd_form_keymap->KeymapErr);
 198         }
 199 }
 200
 201
 202 void Intl::LCombo(int, void * v, Combox * combox)
 203 {
 204         Intl * itl = static_cast<Intl*>(v);
 205         if (combox == itl->Language.get())
 206             itl->Keymap(23);
 207         else if (combox == itl->Language2.get())
 208             itl->Keymap(43);
 209         return;
 210 }
 211
 212
 213 void Intl::DispatchCallback(FL_OBJECT * ob, long code)
 214 {
 215         if (ob && (code == 0)) {
 216                 fl_hide_form(ob->form);
 217                 return;
 218         }
 219         if (!ob || !(ob->u_vdata))
 220                 return;
 221
 222         Intl * itl = static_cast<Intl *>(ob->u_vdata);
 223
 224         if (itl != 0) itl->Keymap(code);
 225 }
 226
 227
 228 extern "C" void C_Intl_DispatchCallback(FL_OBJECT * ob, long code)
 229 {
 230         Intl::DispatchCallback(ob, code);
 231 }
 232
 233
 234 void Intl::InitKeyMapper(bool on)
 235         // initialize key mapper
 236 {
 237         lyxerr[Debug::INIT] << "Initializing key mappings..." << endl;
 238
 239         if (prim_lang.empty() && sec_lang.empty())
 240                 keymapon = false;
 241         else
 242                 keymapon = on;
 243
 244         Language.reset(new Combox(FL_COMBOX_DROPLIST));
 245         Language2.reset(new Combox(FL_COMBOX_DROPLIST));
 246         Language->setcallback(LCombo, this);
 247         Language2->setcallback(LCombo, this);
 248
 249         fd_form_keymap = create_form_KeyMap();
 250
 251         // Add the Intl* pointer
 252         fd_form_keymap->AcceptChset->u_vdata =
 253                 fd_form_keymap->Charset->u_vdata =
 254                 fd_form_keymap->Accept->u_vdata =
 255                 fd_form_keymap->OtherKeymap->u_vdata =
 256                 fd_form_keymap->KeyOnBtn->u_vdata =
 257                 fd_form_keymap->KeyOffBtn->u_vdata =
 258                 fd_form_keymap->KeyOnBtn2->u_vdata = this;
 259
 260         // add the callbacks.
 261         fl_set_object_callback(fd_form_keymap->AcceptChset,
 262                                C_Intl_DispatchCallback, 27);
 263         fl_set_object_callback(fd_form_keymap->Charset,
 264                                C_Intl_DispatchCallback, 26);
 265         fl_set_object_callback(fd_form_keymap->Accept,
 266                                C_Intl_DispatchCallback, 0);
 267
 268         fl_set_object_callback(fd_form_keymap->KeyOnBtn,
 269                                C_Intl_DispatchCallback, 23);
 270         fl_set_object_callback(fd_form_keymap->KeyOffBtn,
 271                                C_Intl_DispatchCallback, 3);
 272         fl_set_object_callback(fd_form_keymap->KeyOnBtn2,
 273                                C_Intl_DispatchCallback, 43);
 274
 275         // Make sure pressing the close box does not kill LyX. (RvdK)
 276         fl_set_form_atclose(fd_form_keymap->KeyMap, CancelCloseBoxCB, 0);
 277
 278         fl_hide_object(fd_form_keymap->KeymapErr);
 279         fl_hide_object(fd_form_keymap->ChsetErr);
 280         fl_set_input(fd_form_keymap->Charset, lyxrc.font_norm.c_str());
 281
 282         // Adds two comboxes to the keyboard map
 283         fl_addto_form(fd_form_keymap->KeyMap);
 284         Language->add(120, 30, 160, 30, 300);   // Primary
 285         Language2->add(120, 110, 160, 30, 300); // Secondary
 286         fl_end_form();
 287
 288         int n = 0;
 289
 290         for (Languages::const_iterator cit = languages.begin();
 291              cit != languages.end(); ++cit) {
 292                 Language->addto((*cit).second.lang());
 293                 Language2->addto((*cit).second.lang());
 294                 ++n;
 295         }
 296
 297         Language->addto(_("other..."));
 298         Language2->addto(_("other..."));
 299         otherkeymap = n + 1;
 300         if (!Language->select_text(prim_lang)) {
 301                 Language->select(n + 1);
 302                 fl_set_input(fd_form_keymap->OtherKeymap, prim_lang.c_str());
 303         } else
 304                 trans.SetPrimary(prim_lang);
 305
 306         if (!Language2->select_text(sec_lang)) {
 307                 Language2->select(n + 1);
 308                 fl_set_input(fd_form_keymap->OtherKeymap2, sec_lang.c_str());
 309         } else
 310                 trans.SetSecondary(sec_lang);
 311
 312         KeyMapOn(keymapon);
 313         if (keymapon)
 314                 Keymap(23); // turn primary on
 315         trans.setCharset(lyxrc.font_norm);
 316 }
 317
 318
 319 void Intl::Keymap(long code)
 320 {
 321         if (lyxerr.debugging(Debug::KBMAP))
 322                 lyxerr << "KeyMap callback: " << code << endl;
 323
 324         // Did you wonder if it is possible to write spagetti code with
 325         // other constructs thatn goto's? Well here we have a nice small
 326         // spagetti example using a switch... (Lgb)
 327         switch (code) {
 328         case 0:
 329                 // cancel/hide
 330                 fl_hide_form(fd_form_keymap->KeyMap);
 331                 break;
 332         case 3:
 333         case 23:
 334         case 43:
 335                 if (code == 3) {
 336                         KeyMapOn(false);
 337                         return;
 338                 }
 339                 code -= 19;     // change to language change type code
 340
 341         case 4: // 4 and 24 will never be called directly, they will only be
 342         case 24: // called through 3, 23, 43 (lgb)
 343                 if (code == 4) {
 344                         KeyMapPrim();
 345                 } else {
 346                         KeyMapSec();
 347                 }
 348                 break;
 349         case 27:        // set new font norm
 350                 char const * p = fl_get_input(fd_form_keymap->Charset);
 351                 if (trans.setCharset(p))
 352                         fl_show_object(fd_form_keymap->ChsetErr);
 353                 else
 354                         fl_hide_object(fd_form_keymap->ChsetErr);
 355                 break;
 356         }
 357 }
 358
 359
 360 void Intl::MenuKeymap()
 361 {
 362         if (fd_form_keymap->KeyMap->visible) {
 363                 fl_raise_form(fd_form_keymap->KeyMap);
 364         } else fl_show_form(fd_form_keymap->KeyMap,
 365                             FL_PLACE_MOUSE | FL_FREE_SIZE, FL_TRANSIENT,
 366                             _("Key Mappings"));
 367 }