home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / lyx-0.13.2.tar.gz / lyx-0.13.2.tar / lyx-0.13.2 / src / trans_mgr.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  7KB  |  392 lines
  1.  
  2. #ifdef __GNUG__
  3. #pragma implementation "trans_mgr.h"
  4. #endif
  5.  
  6. #include <assert.h>
  7. #include "trans_mgr.h"
  8. #include "trans.h"
  9. #include "lyxtext.h"
  10. #include "LString.h"
  11. #include "error.h"
  12. #include "chset.h"
  13. #include "insetlatexaccent.h"
  14. #include "BufferView.h"
  15. #include "buffer.h"
  16. #include "lyxrc.h"
  17.  
  18. extern LyXRC* lyxrc;
  19. extern LString DoAccent(const LString&,tex_accent);
  20. extern void InsertCorrectQuote();
  21. extern LString DoAccent(char,tex_accent);
  22. extern BufferView* current_view;
  23.  
  24.  
  25. // TransFSMData
  26. TransFSMData::TransFSMData()
  27. {
  28.     deadkey_=deadkey2_=0;
  29.     deadkey_info_.accent=deadkey2_info_.accent=TEX_NOACCENT;
  30.     comb_info_=NULL;
  31. }
  32.  
  33.  
  34. // TransState
  35. const char TransState::TOKEN_SEP=4;
  36.  
  37.  
  38. TransState::~TransState()
  39. {}
  40.  
  41.  
  42. // TransInitState
  43. TransInitState::TransInitState()
  44. {
  45.     init_state_=this;
  46. }
  47.  
  48.  
  49. LString TransInitState::normalkey(char c,char *t)
  50. {
  51.     LString res;
  52.     if (t!=NULL)
  53.     res=t;
  54.     else
  55.     res=c;
  56.     
  57.     return res;
  58. }
  59.  
  60.  
  61. //bool TransInitState::backspace()
  62. //{
  63. //    return true;
  64. //}
  65.  
  66.  
  67. LString TransInitState::deadkey(char c,KmodInfo d)
  68. {
  69.     deadkey_=c;
  70.     deadkey_info_=d;
  71.     currentState=deadkey_state_;
  72.     return LString();
  73. }
  74.  
  75.  
  76. // TransDeadkeyState
  77. TransDeadkeyState::TransDeadkeyState()
  78. {
  79.     deadkey_state_=this;
  80. }
  81.  
  82.  
  83. LString TransDeadkeyState::normalkey(char c,char *trans)
  84. {
  85.     LString res;
  86.     
  87.     // Check if it is an exception
  88.     KmodException l=deadkey_info_.exception_list;
  89.     while(l!=NULL) {
  90.     if (l->c==c) {
  91.         res=l->data;
  92.         break;
  93.     }
  94.     l=l->next;
  95.     }
  96.     if (l==NULL) {
  97.     // Not an exception. Check if it allowed
  98.     if (current_view->currentBuffer()->params.allowAccents==true ||
  99.         deadkey_info_.allowed.countChar(c)>0) {
  100.         res=DoAccent(c,deadkey_info_.accent);
  101.     } else {
  102.         // Not allowed
  103.         if (deadkey_!=0)
  104.         res=deadkey_;
  105.         res+=TOKEN_SEP;
  106.         res+=trans;
  107.     }
  108.     }
  109.     currentState=init_state_;
  110.     return res;
  111. }
  112.  
  113.  
  114. //bool TransDeadkeyState::backspace()
  115. //{
  116. //    currentState=init_state_;
  117. //    return false;
  118. //}
  119.  
  120.  
  121. LString TransDeadkeyState::deadkey(char c,KmodInfo d)
  122. {
  123.     LString res;
  124.     
  125.     // Check if the same deadkey was typed twice
  126.     if (deadkey_==c) {
  127.     res=deadkey_;
  128.     deadkey_=0;
  129.     deadkey_info_.accent=TEX_NOACCENT;
  130.     currentState=init_state_;
  131.     return res;
  132.     }
  133.     
  134.     // Check if it is a combination or an exception
  135.     KmodException l;
  136.     l=deadkey_info_.exception_list;
  137.     
  138.     while(l) {
  139.     if (l->combined==true && l->accent==d.accent) {
  140.         deadkey2_=c;
  141.         deadkey2_info_=d;
  142.         comb_info_=l;
  143.         currentState=combined_state_;
  144.         return LString();
  145.     }
  146.     if (l->c==c) {
  147.         res=l->data;
  148.         deadkey_=0;
  149.         deadkey_info_.accent=TEX_NOACCENT;
  150.         currentState=init_state_;
  151.         return res;
  152.     }
  153.     
  154.     l=l->next;
  155.     }
  156.     
  157.     // Not a combination or an exception. 
  158.     // Output deadkey1 and keep deadkey2
  159.     
  160.     if (deadkey_!=0)
  161.     res=deadkey_;
  162.     deadkey_=c;
  163.     deadkey_info_=d;
  164.     currentState=deadkey_state_;
  165.     return res;
  166. }
  167.  
  168.  
  169. TransCombinedState::TransCombinedState()
  170. {
  171.     combined_state_=this;
  172. }
  173.  
  174.  
  175. LString TransCombinedState::normalkey(char c,char *trans)
  176. {
  177.     LString res;
  178.     
  179.     // Check if the key is allowed on the combination
  180.     if (comb_info_->data.countChar(c)>0) {
  181.     LString temp;
  182.     temp=DoAccent(c,deadkey2_info_.accent);
  183.     res=DoAccent(temp,deadkey_info_.accent);
  184.     currentState=init_state_;
  185.     } else {
  186.     // Not allowed. Output deadkey1 and check deadkey2 + c
  187.     if (deadkey_!=0)
  188.         res+=deadkey_;
  189.     res+=TOKEN_SEP;
  190.     deadkey_=deadkey2_;
  191.     deadkey_info_=deadkey2_info_;
  192.     // Call deadkey state and leave it to setup the FSM
  193.     res+=deadkey_state_->normalkey(c,trans);
  194.     }
  195.     return res;
  196. }
  197.  
  198.  
  199. // bool TransCombinedState::backspace()
  200. // {
  201. //     // cancel the second deadkey
  202. //     deadkey2_=0;
  203. //     deadkey2_info_.accent=TEX_NOACCENT;
  204. //     currentState=deadkey_state_;
  205.     
  206. //     return false;
  207. // }
  208.  
  209.  
  210. LString TransCombinedState::deadkey(char c,KmodInfo d)
  211. {
  212.     // Third key in a row. Output the first one and
  213.     // reenter with shifted deadkeys
  214.     LString res;
  215.     if (deadkey_!=0)
  216.     res=deadkey_;
  217.     res+=TOKEN_SEP;
  218.     deadkey_=deadkey2_;
  219.     deadkey_info_=deadkey2_info_;
  220.     res+=deadkey_state_->deadkey(c,d);
  221.     return res;
  222. }
  223.  
  224.  
  225. // TransFSM
  226. TransFSM::TransFSM():
  227.     TransFSMData(),
  228.     TransInitState(),
  229.     TransDeadkeyState(),
  230.     TransCombinedState()
  231. {
  232.     currentState=init_state_;
  233. }
  234.  
  235.  
  236. // TransManager
  237.     
  238. TransManager::TransManager()
  239.     : active_(NULL),t1_(new Trans),t2_(new Trans),chset_(new CharacterSet)
  240. {}
  241.  
  242.  
  243. Trans* TransManager::default_=new Trans;
  244.  
  245.  
  246. TransManager::~TransManager() 
  247. { 
  248.     delete t1_;
  249.     delete t2_;
  250.     delete chset_;
  251. }
  252.  
  253.  
  254. int TransManager::SetPrimary(LString const & language)
  255. {
  256.     if (t1_->GetName()==language) 
  257.     return 0;
  258.     
  259.     return t1_->Load(language);
  260. }
  261.  
  262.  
  263. int TransManager::SetSecondary(LString const & language)
  264. {
  265.     if (t2_->GetName()==language)
  266.     return 0;
  267.     
  268.     return t2_->Load(language);
  269. }
  270.  
  271.  
  272. bool TransManager::setCharset(const char *set)
  273. {
  274.     return chset_->loadFile(set);
  275. }
  276.  
  277.  
  278. void TransManager::EnablePrimary()
  279. {
  280.     if (t1_->IsDefined())
  281.     active_=t1_;
  282.  
  283.     lyxerr.debug("Enabling primary keymap",Error::KBMAP);
  284. }
  285.  
  286.  
  287. void TransManager::EnableSecondary()
  288. {
  289.     if (t2_->IsDefined( ))
  290.     active_=t2_;
  291.     lyxerr.debug("Enabling secondary keymap",Error::KBMAP);
  292. }
  293.  
  294.  
  295. void TransManager::DisableKeymap()
  296. {
  297.     active_=default_;
  298.     lyxerr.debug("Disabling keymap",Error::KBMAP);
  299. }
  300.  
  301.  
  302. void  TransManager::TranslateAndInsert(char c,LyXText *text)
  303. {
  304.     LString res;
  305.     
  306.     res=active_->process(c,*this);
  307.     
  308.     // Process with tokens
  309.     LString temp;
  310.     
  311.     while(res.length()>0) {
  312.     res.split(temp,TransState::TOKEN_SEP);
  313.     insert(temp,text);
  314.     }
  315. }
  316.  
  317.  
  318. void TransManager::insertVerbatim(const LString& str,LyXText *text)
  319. {    
  320.     int l=str.length();
  321.     
  322.     for (int i=0;i<l;i++){
  323.     if (str[i]=='\"' 
  324.         && text->GetFont(text->cursor.par,
  325.                  text->cursor.pos).latex() == LyXFont::OFF)
  326.         InsertCorrectQuote();
  327.     else
  328.         text->InsertChar(str[i]);
  329.     }
  330. }
  331.  
  332.  
  333. void TransManager::insert(LString str,LyXText *text)
  334. {
  335.     LString t=str;
  336.     
  337.     // Go through the character encoding only if the current 
  338.     // encoding (chset_->name()) matches the current font_norm
  339.     // (lyrxc->font_norm
  340.  
  341.     if (chset_->getName()!=lyxrc->font_norm || 
  342.     chset_->encodeString(str)==false) {
  343.     // Could not find an encoding
  344.     InsetLatexAccent ins(str);
  345.     if (ins.CanDisplay()) {
  346.         text->InsertInset(new InsetLatexAccent(ins));
  347.         return;
  348.     }
  349.     }
  350.     
  351.     insertVerbatim(str,text);
  352. }
  353.  
  354.  
  355. //bool TransManager::backspace()
  356. //{
  357. //    return trans_fsm_.currentState->backspace();
  358. //}
  359.  
  360.  
  361. void TransManager::deadkey(char c,tex_accent accent,LyXText *t)
  362. {
  363.     KmodInfo i;
  364.     LString res;
  365.     
  366.     if (c==0 && active_!=default_) {
  367.     // A deadkey was pressed that cannot be printed
  368.     // or a accent command was typed in the minibuffer
  369.     
  370.     if (active_->isAccentDefined(accent,i)==true) {
  371.         res=trans_fsm_.currentState->deadkey(c,i);
  372.         insert(res,t);
  373.         return;
  374.     }
  375.     }// else {
  376.     // Fall through to the next case
  377.     //}
  378.     
  379.     if (active_==default_ || c==0) {
  380.     i.accent=accent;
  381.     i.allowed=lyx_accent_table[accent].native;
  382.     i.data.erase();
  383.     i.exception_list=NULL;
  384.     
  385.     LString res=trans_fsm_.currentState->deadkey(c,i);
  386.     insert(res,t);
  387.     } else {
  388.     // Go through the translation
  389.     TranslateAndInsert(c,t);
  390.     }
  391. }
  392.