← Back to branch summary

~alanbell/dasher/ircfix-lp579181

« back to all changes in this revision

Viewing changes to Src/DasherCore/AlphabetManager.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2006-11-14 12:03:42 UTC
  • mfrom: (1.2.14 upstream)
  • Revision ID: james.westby@ubuntu.com-20061114120342-pebcosas78lczcgz
Tags: 4.3.1-0ubuntu1
* New upstream release:
  - 4.3.1:
    - Bugfixes
    - Translation updates
  - 4.3.0:
    - Mainly work on two button dynamic mode to provide a platform for 
      user tests
* debian/patches/10_remove-extra-qualifier.patch:
  - fix FTBFS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Src/DasherCore/AlphabetManager.cpp
2
2
#include "../Common/Common.h"
3
3
 
4
4
#include "AlphabetManager.h"
5
 
#include "DasherModel.h"
 
5
//#include "DasherModel.h"
6
6
#include "DasherNode.h"
7
7
#include "Event.h"
8
8
#include "EventHandler.h"
 
9
#include "NodeCreationManager.h"
9
10
 
10
11
#include <vector>
11
12
#include <iostream>
22
23
#endif
23
24
#endif
24
25
 
25
 
CAlphabetManager::CAlphabetManager( CDasherModel *pModel, CLanguageModel *pLanguageModel, bool bGameMode, const std::string &strGameModeText ) 
26
 
  : CNodeManager(0), m_pLanguageModel(pLanguageModel), m_pModel(pModel) {
 
26
CAlphabetManager::CAlphabetManager( CNodeCreationManager *pNCManager, CLanguageModel *pLanguageModel, CLanguageModel::Context iLearnContext, bool bGameMode, const std::string &strGameModeText ) 
 
27
  : CNodeManager(0), m_pLanguageModel(pLanguageModel), m_pNCManager(pNCManager) {
27
28
 
 
29
  m_iLearnContext = iLearnContext;
28
30
  m_bGameMode = bGameMode;
29
31
  m_strGameString = strGameModeText;
30
32
}
46
48
  if(iSymbol == 0)
47
49
    iColour = 7;
48
50
  else
49
 
    iColour = m_pModel->GetColour(iSymbol);
 
51
    iColour = m_pNCManager->GetColour(iSymbol);
50
52
 
51
53
  pNewNode = new CDasherNode(pParent, iSymbol, 0, Opts::Nodes1, iLower, iUpper, m_pLanguageModel, iColour);
52
54
  
53
 
  pNewNode->SetContext(m_pLanguageModel->CreateEmptyContext()); // FIXME - handle context properly
 
55
  //  pNewNode->SetContext(m_pLanguageModel->CreateEmptyContext()); // FIXME - handle context properly
54
56
  pNewNode->m_pNodeManager = this;
55
57
  pNewNode->m_bShove = true;
56
 
  pNewNode->m_pBaseGroup = m_pModel->GetAlphabet().m_pBaseGroup;
57
 
  pNewNode->m_strDisplayText = m_pModel->GetAlphabet().GetDisplayText(iSymbol);
 
58
  pNewNode->m_pBaseGroup = m_pNCManager->GetAlphabet()->m_pBaseGroup;
 
59
  pNewNode->m_strDisplayText = m_pNCManager->GetAlphabet()->GetDisplayText(iSymbol);
58
60
  pNewNode->Seen(true);
59
61
 
60
62
  SAlphabetData *pNodeUserData = new SAlphabetData;
62
64
 
63
65
  pNodeUserData->iPhase = 0;
64
66
  pNodeUserData->iSymbol = iSymbol;
 
67
  pNodeUserData->pLanguageModel = m_pLanguageModel;
 
68
 
 
69
  // Hopefully this will obsolete any need to handle contexts outside
 
70
  // of the alphabet manager - check this and remove resulting
 
71
  // redundant code
 
72
  CLanguageModel::Context iContext;
 
73
  iContext = m_pLanguageModel->CreateEmptyContext();
 
74
  pNodeUserData->iContext = iContext;
65
75
 
66
76
  if(m_bGameMode) {
67
77
    pNodeUserData->iGameOffset = -1;
79
89
  int iOldPhase(static_cast<SAlphabetData *>(pNode->m_pUserData)->iPhase);
80
90
  int iNewPhase((iOldPhase + 1) % 2);
81
91
 
 
92
  SAlphabetData *pParentUserData(static_cast<SAlphabetData *>(pNode->m_pUserData));
82
93
 
83
94
  // Actually create the children here
84
95
  
86
97
  std::vector < symbol > newchars; // place to put this list of characters
87
98
  std::vector < unsigned int >cum; // for the probability list
88
99
  
89
 
  m_pModel->GetProbs(pNode->Context(), newchars, cum, m_pModel->GetLongParameter(LP_NORMALIZATION));
 
100
  // TODO: Need to fix up relation to language model here (use one from node, not global).
 
101
  m_pNCManager->GetProbs(pParentUserData->iContext, newchars, cum, m_pNCManager->GetLongParameter(LP_NORMALIZATION));
90
102
  int iChildCount = newchars.size();
91
103
  
92
104
  // work out cumulative probs in place
100
112
  for(int j = 0; j < iChildCount; j++) {
101
113
    CDasherNode *pNewNode;
102
114
    
103
 
    if(newchars[j] == m_pModel->GetControlSymbol())
104
 
      pNewNode = m_pModel->GetRoot(1, pNode, iLbnd, cum[j], NULL);
105
 
    else if(newchars[j] == m_pModel->GetStartConversionSymbol()) {
106
 
#ifdef JAPANESE
107
 
      pNewNode = m_pModel->GetRoot(2, pNode, iLbnd, cum[j], NULL);
108
 
#else
109
 
      pNewNode = m_pModel->GetRoot(0, pNode, iLbnd, cum[j], NULL);
110
 
      pNewNode->Seen(false);
111
 
#endif
 
115
    if(newchars[j] == m_pNCManager->GetControlSymbol())
 
116
      pNewNode = m_pNCManager->GetRoot(1, pNode, iLbnd, cum[j], NULL);
 
117
    else if(newchars[j] == m_pNCManager->GetStartConversionSymbol()) {
 
118
      // TODO: Need to consider the case where there is no compile-time support for this
 
119
      pNewNode = m_pNCManager->GetRoot(2, pNode, iLbnd, cum[j], NULL);
112
120
    }
113
121
    else if( newchars[j] == iExistingSymbol) {
114
122
      pNewNode = pExistingChild;
115
123
      pNewNode->SetRange(iLbnd, cum[j]);
116
124
    }
117
125
    else {
118
 
      int iColour(m_pModel->GetColour(newchars[j]));
 
126
      int iColour(m_pNCManager->GetColour(newchars[j]));
119
127
 
120
128
      // This is provided for backwards compatibility. 
121
129
      // Colours should always be provided by the alphabet file
122
130
      if(iColour == -1) {
123
 
        if(newchars[j] == m_pModel->GetSpaceSymbol()) {
 
131
        if(newchars[j] == m_pNCManager->GetSpaceSymbol()) {
124
132
          iColour = 9;
125
133
        }
126
 
        else if(newchars[j] == m_pModel->GetControlSymbol()) {
 
134
        else if(newchars[j] == m_pNCManager->GetControlSymbol()) {
127
135
          iColour = 8;
128
136
        }
129
137
        else {
135
143
      if(iNewPhase == 1 && iColour < 130) // We don't loop on high
136
144
        iColour += 130;
137
145
      
138
 
      pNewNode = new CDasherNode(pNode, newchars[j], 0, Nodes1, iLbnd, cum[j], m_pLanguageModel, iColour);
 
146
      pNewNode = new CDasherNode(pNode, newchars[j], 0, Nodes1, iLbnd, cum[j], pParentUserData->pLanguageModel, iColour);
139
147
      pNewNode->m_pNodeManager = this;
140
148
      pNewNode->m_bShove = true;
141
 
      pNewNode->m_pBaseGroup = m_pModel->GetAlphabet().m_pBaseGroup;
 
149
      pNewNode->m_pBaseGroup = m_pNCManager->GetAlphabet()->m_pBaseGroup;
142
150
      
143
151
      SAlphabetData *pNodeUserData = new SAlphabetData;
144
152
      pNewNode->m_pUserData = pNodeUserData;
149
157
      if(m_bGameMode) {
150
158
        int iCurrentGameOffset(static_cast<SAlphabetData *>(pNode->m_pUserData)->iGameOffset);
151
159
        
152
 
        if((iCurrentGameOffset != -2) && ((iCurrentGameOffset + 1) < m_strGameString.size()) 
153
 
           && ((m_pModel->GetAlphabet().GetText(newchars[j]))[0] == m_strGameString[iCurrentGameOffset + 1])) {
 
160
        if((iCurrentGameOffset != -2) && ((iCurrentGameOffset + 1) < static_cast<int>(m_strGameString.size())) 
 
161
           && ((m_pNCManager->GetAlphabet()->GetText(newchars[j]))[0] == m_strGameString[iCurrentGameOffset + 1])) {
154
162
          static_cast<SAlphabetData *>(pNewNode->m_pUserData)->iGameOffset = iCurrentGameOffset + 1;
155
163
          pNewNode->SetGame(true);
156
164
        }
157
165
        else
158
166
          static_cast<SAlphabetData *>(pNewNode->m_pUserData)->iGameOffset = -2;
159
167
      }
 
168
 
 
169
      CLanguageModel::Context iContext;
 
170
      iContext = m_pLanguageModel->CloneContext(pParentUserData->iContext);
 
171
      m_pLanguageModel->EnterSymbol(iContext, newchars[j]); // TODO: Don't use symbols?
 
172
      
 
173
      pNodeUserData->pLanguageModel = pParentUserData->pLanguageModel;
 
174
      pNodeUserData->iContext = iContext;
 
175
      
 
176
      //      pNewNode->SetContext(iContext); // FIXME - handle context properly
160
177
    }
161
178
    
162
 
    pNewNode->m_strDisplayText = m_pModel->GetAlphabet().GetDisplayText(newchars[j]);
163
 
    
 
179
    pNewNode->m_strDisplayText = m_pNCManager->GetAlphabet()->GetDisplayText(newchars[j]);
164
180
    
165
181
    pNode->Children()[j] = pNewNode;
166
182
    iLbnd = cum[j];
170
186
}
171
187
 
172
188
void CAlphabetManager::ClearNode( CDasherNode *pNode ) {
173
 
  delete static_cast<SAlphabetData *>(pNode->m_pUserData);
 
189
  SAlphabetData *pUserData(static_cast<SAlphabetData *>(pNode->m_pUserData));
 
190
  
 
191
  pUserData->pLanguageModel->ReleaseContext(pUserData->iContext);
 
192
  delete pUserData;
174
193
}
175
194
 
176
195
void CAlphabetManager::Output( CDasherNode *pNode, Dasher::VECTOR_SYMBOL_PROB* pAdded, int iNormalization) {
177
 
  m_pModel->m_bContextSensitive = true;
 
196
  //  m_pNCManager->m_bContextSensitive = true;
178
197
  symbol t = static_cast<SAlphabetData *>(pNode->m_pUserData)->iSymbol;
179
198
 
180
199
  if(t) { // Ignore symbol 0 (root node)
181
 
    Dasher::CEditEvent oEvent(1, m_pModel->GetAlphabet().GetText(t));
182
 
    m_pModel->InsertEvent(&oEvent);
 
200
    Dasher::CEditEvent oEvent(1, m_pNCManager->GetAlphabet()->GetText(t));
 
201
    m_pNCManager->InsertEvent(&oEvent);
183
202
 
184
203
    // Track this symbol and its probability for logging purposes
185
204
    if (pAdded != NULL) {
195
214
void CAlphabetManager::Undo( CDasherNode *pNode ) {
196
215
  symbol t = static_cast<SAlphabetData *>(pNode->m_pUserData)->iSymbol;
197
216
  if(t) { // Ignore symbol 0 (root node)
198
 
    Dasher::CEditEvent oEvent(2, m_pModel->GetAlphabet().GetText(t));
199
 
    m_pModel->InsertEvent(&oEvent);
 
217
    Dasher::CEditEvent oEvent(2, m_pNCManager->GetAlphabet()->GetText(t));
 
218
    m_pNCManager->InsertEvent(&oEvent);
200
219
  }
201
220
}
202
221
 
203
222
CDasherNode *CAlphabetManager::RebuildParent(CDasherNode *pNode, int iGeneration) {
204
223
 
 
224
  // TODO: Reimplement -----
 
225
 
205
226
  // Ask for context information
206
 
  m_pModel->m_strContextBuffer = "";
207
 
  Dasher::CEditContextEvent oEvent(10);
208
 
  m_pModel->InsertEvent(&oEvent);
 
227
  //  m_pNCManager->m_strContextBuffer = "";
 
228
  //  Dasher::CEditContextEvent oEvent(10);
 
229
  //  m_pNCManager->InsertEvent(&oEvent);
209
230
 
210
 
  std::string strContext(m_pModel->m_strContextBuffer);
 
231
  //  std::string strContext(m_pNCManager->m_strContextBuffer);
211
232
  std::vector<symbol> vSymbols;
212
 
  m_pLanguageModel->SymbolAlphabet().GetAlphabetPointer()->GetSymbols(&vSymbols, &strContext, false);
 
233
  //  m_pLanguageModel->SymbolAlphabet().GetAlphabetPointer()->GetSymbols(&vSymbols, &strContext, false);
213
234
 
 
235
  // -----
214
236
 
215
237
  CDasherNode *pNewNode;
216
238
 
219
241
 
220
242
  symbol iNewSymbol;
221
243
 
222
 
  if(vSymbols.size() <= iGeneration + 1) {
 
244
  CLanguageModel::Context oContext(m_pLanguageModel->CreateEmptyContext());
 
245
 
 
246
  if(static_cast<int>(vSymbols.size()) <= iGeneration + 1) {
223
247
    // Create a root node if there isn't any more context
224
248
    iNewPhase = 0;
225
249
    iNewSymbol = 0;
227
251
    pNewNode = new CDasherNode(0, 0, 0,  Opts::Nodes1, 0, 0, m_pLanguageModel, 7);
228
252
    
229
253
    // TODO: Horrible hard coded default context
230
 
    CLanguageModel::Context oContext(m_pLanguageModel->CreateEmptyContext());
231
 
    m_pModel->EnterText(oContext, ". ");
232
 
    pNewNode->SetContext(oContext);
 
254
    m_pNCManager->EnterText(oContext, ". ");
233
255
  }
234
256
  else {
235
257
    
236
258
    iNewPhase = ((iOldPhase + 2 - 1) % 2);
237
259
    iNewSymbol = vSymbols[vSymbols.size() - iGeneration - 2];
238
260
 
239
 
    int iColour(m_pModel->GetColour(vSymbols[vSymbols.size() - iGeneration - 2]));
 
261
    int iColour(m_pNCManager->GetColour(vSymbols[vSymbols.size() - iGeneration - 2]));
240
262
 
241
263
    // Loop colours if necessary for the colour scheme
242
264
    if(iNewPhase == 1)
243
265
      iColour += 130;
244
266
            
245
267
    pNewNode = new CDasherNode(0, iNewSymbol, 0, Nodes1, 0, 0, m_pLanguageModel, iColour);
246
 
    CLanguageModel::Context oContext(m_pLanguageModel->CreateEmptyContext());
247
 
    
248
 
    for(int i(0); i < vSymbols.size() - iGeneration -1; ++i)
 
268
 
 
269
    for(unsigned int i(0); i < vSymbols.size() - iGeneration -1; ++i)
249
270
      m_pLanguageModel->EnterSymbol(oContext, vSymbols[i]);
250
 
    
251
 
    pNewNode->SetContext(oContext);
252
271
  }
253
272
  
254
273
  pNewNode->m_pNodeManager = this;
255
274
  pNewNode->m_bShove = true;
256
275
  pNewNode->Seen(true);
257
 
  pNewNode->m_pBaseGroup = m_pModel->GetAlphabet().m_pBaseGroup;
 
276
  pNewNode->m_pBaseGroup = m_pNCManager->GetAlphabet()->m_pBaseGroup;
258
277
 
259
278
  SAlphabetData *pNodeUserData = new SAlphabetData;
260
279
  pNewNode->m_pUserData = pNodeUserData;
261
280
 
262
281
  pNodeUserData->iPhase = iNewPhase;
263
282
  pNodeUserData->iSymbol = iNewSymbol;
 
283
  pNodeUserData->pLanguageModel = m_pLanguageModel;
 
284
  pNodeUserData->iContext = oContext;
264
285
 
265
286
  PopulateChildrenWithSymbol(pNewNode, static_cast<SAlphabetData *>(pNode->m_pUserData)->iSymbol, pNode);
266
287
 
268
289
  
269
290
  return pNewNode;
270
291
}
 
292
 
 
293
void CAlphabetManager::SetFlag(CDasherNode *pNode, int iFlag, bool bValue) {
 
294
  switch(iFlag) {
 
295
  case NF_COMMITTED:
 
296
    if(bValue)
 
297
      // TODO: Reimplement (need a learning context, check whether symbol actually corresponds to character)
 
298
      static_cast<SAlphabetData *>(pNode->m_pUserData)->pLanguageModel->LearnSymbol(m_iLearnContext, static_cast<SAlphabetData *>(pNode->m_pUserData)->iSymbol);
 
299
    break;
 
300
  }
 
301
}