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