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