?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
HowManyAreAnalyzed(): use status_user_agent to report progress
[linguistica.git] / linguisticamainwindow.cpp
blob4581abc968a8ee09b9c95910c21d6b7519fede04
1 // Implementation of most LinguisticaMainWindow methods
2 // Copyright © 2009 The University of Chicago
3 #include "linguisticamainwindow.h"
4
5 #include "Config.h"
6 #include "Version.h"
7 #include <memory>
8 #include <limits>
9 #include <cstdio>
10 #include <QDesktopWidget>
11 #include <QProgressBar>
12 #include <QMessageBox>
13 #include <Q3PopupMenu>
14 #include <Q3ListView>
15 #include <QResizeEvent>
16 #include <QCloseEvent>
17 #include <QMoveEvent>
18 #include <QLabel>
19 #include <Q3TextStream>
20 #include <Q3ValueList>
21 #include "listbuilderdialog.h"
22 #include "helpaboutdialog.h"
23 #include "verifydialog.h"
24 #include "LPreferences.h"
25 #include "GraphicView.h"
26 #include "GUIclasses.h"
27 #include "gui/Status.h"
28 #include "Sequencer.h"
29 #include "DLHistory.h"
30 #include "Stats.h"
31 #include "FSA.h"
32 #include "cMT.h"
33 #include "MiniLexicon.h"
34 #include "Lexicon.h"
35 #include "Signature.h"
36 #include "Template.h"
37 #include "SignatureCollection.h"
38 #include "TemplateCollection.h"
39 #include "SuffixCollection.h"
40 #include "PrefixCollection.h"
41 #include "StemCollection.h"
42 #include "WordCollection.h"
43 #include "CommandLine.h"
44 #include "Slice.h"
45 //#include <QTime>
46
47 namespace {
48 // command-line argument parsing helper
49 struct command_line_args {
50 QString corpus, logFile, goldStdFile, outputDir, error;
51 bool mini;
52 bool prefix;
53 bool suffix;
54 bool verbose;
55 int count;
56
57 command_line_args() : mini(false),
58 prefix(false), suffix(false),
59 verbose(false), count(0) { }
60 /// result is false for --help and errors
61 bool process(int argc, char** argv)
62 {
63 return processCommandLineArgs(argc, argv,
64 corpus, count, logFile, goldStdFile,
65 outputDir, mini, prefix, suffix,
66 verbose, error) >= 0;
67 }
68 };
69 }
70
71 LinguisticaMainWindow::LinguisticaMainWindow( const int argc, char** argv,
72 QApplication* app, QWidget* parent, Qt::WindowFlags f )
73 : QMainWindow(parent, f), Ui::LinguisticaMainWindowBase(),
74 // Application
75 m_app(app),
76 m_commandLineFlag(argc > 1),
77 // Preferences
78 // XXX. set organization string "UChicago", application "Linguistica"
79 m_Settings(),
80 m_preferences(&m_Settings),
81 // Lexicon
82 m_lexicon(new CLexicon(this)),
83 // GUI
84 m_docType(NO_DOC),
85 m_commandParse(),
86 m_commandMini(-1),
87 m_pSig1(), m_pSig2(),
88 m_GUIWords(),
89 // Token count
90 m_numberOfTokens(0),
91 // Log file.
92 m_logging(false),
93 m_logFileName(m_Settings.value(
94 "/linguistica.uchicago.edu/Linguistica/MainWindow/LogFile/FileName",
95 QString("C:\\.txt")).value<QString>()),
96 m_logFile(),
97 m_logFileStream(),
98 // Status/Progress bar
99 m_status(),
100 m_progressDialog(),
101 m_progressText1(), m_progressText2(),
102 // Counter
103 m_counterDisplayFlag(false),
104 m_counter(0),
105 // Project settings
106 m_projectIndex(0),
107 m_projectDirectory(m_Settings.value(
108 "/linguistica.uchicago.edu/Linguistica/Project/Directory",
109 QString()).value<QString>()),
110 m_projectName(),
111 m_projectDirty(false), // No changes yet
112 // Filenames
113 m_corpusFileName(m_Settings.value(
114 "/linguistica.uchicago.edu/Linguistica/MainWindow/FileMenu/Open",
115 QString()).value<QString>()),
116 m_goldStdFileName(m_Settings.value(
117 "/linguistica.uchicago.edu/Linguistica/MainWindow/DiagnosticsMenu/NewGoldStdFile",
118 QString()).value<QString>()),
119 m_goldStdOutputFile(),
120 // Encoding
121 m_EncodingType(m_Settings.value(
122 "/linguistica.uchicago.edu/Linguistica/MainWindow/Encoding/EncodingType",
123 QString()).value<QString>()),
124 // Fonts
125 m_eastFont(m_preferences.GetFontPreference("Main")),
126 // FSA
127 m_CommonState(),
128 // String edit distance
129 m_CommonTemplate(),
130 m_Words_InitialTemplates(), m_Words_Templates(),
131 m_Sequencer(new CSequencer),
132 m_Stats(new CStats(this)),
133 m_MT(),
134 m_SmallCanvas(new Q3Canvas(10, 10)),
135 m_SmallGraphicDisplay(), // initialized below
136 m_SmallGraphicDisplayVBox()
137 {
138 using std::auto_ptr;
139 using std::printf;
140
141 command_line_args args;
142 if (m_commandLineFlag && !args.process(argc, argv)) {
143 printf("%s", args.error.ascii());
144 DisplayHelp();
145 return;
146 }
147
148 setupUi(this);
149 setCaption("Linguistica " + QString(LXA_VERSION));
150
151 {
152 // Set up the status bars
153 using std::auto_ptr;
154 using linguistica::ui::qt::status_interface;
155
156 auto_ptr<QLabel> statusBar1(new QLabel(this));
157 auto_ptr<QLabel> statusBar2(new QLabel(this));
158 auto_ptr<QProgressBar> progressBar(new QProgressBar);
159 m_status = auto_ptr<status_interface>(new status_interface(
160 *statusBar1.get(), *statusBar2.get(), *progressBar.get()));
161
162 statusBar1->setMaximumWidth(250);
163 progressBar->setMaximumWidth(250);
164 statusBar2->setMaximumWidth(250);
165 statusBar()->addPermanentWidget(statusBar1.release(), 33);
166 statusBar()->addPermanentWidget(progressBar.release(), 33);
167 statusBar()->addPermanentWidget(statusBar2.release(), 33);
168 }
169
170 m_commandLine->setWordWrap( Q3TextEdit::NoWrap );
171
172 // Toolbars and Status Bar visible
173 viewToolbarsAction->setOn(true);
174 viewStatusBarAction->setOn(true);
175
176 // Set up Help menu
177 auto_ptr<Q3PopupMenu> help(new Q3PopupMenu(this));
178 // Web links in windows version only
179 auto_ptr<Q3PopupMenu> links(new Q3PopupMenu(this));
180 links->insertItem( "&John Goldsmith", this, SLOT(jgWebLinksActionSlot()) );
181 links->insertItem( "&Linguistica", this, SLOT(lxaWebLinksActionSlot()) );
182 help->insertItem( "&Web Links", links.release() );
183 help->insertSeparator();
184 help->insertItem( "&About", this, SLOT( helpAboutSlot() ) );
185 menuBar()->insertItem( "&Help", help.release() );
186
187 // Graphic view.
188
189 // memory owned by m_SmallGraphicDisplayTab
190 m_SmallGraphicDisplay = new GraphicView(m_SmallCanvas,
191 NULL, m_SmallGraphicDisplayTab);
192 m_SmallGraphicDisplayTab->layout()->addWidget(m_SmallGraphicDisplay);
193
194 // added ...
195 this->pImgLabel = new QLabel;
196 this->pImgLabel->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
197 this->pImgLabel->setAlignment(Qt::AlignCenter);
198 this->pImgLabel->setMinimumSize(240, 160);
199 QVBoxLayout* smGraphicDisplayLayout = new QVBoxLayout;
200 smGraphicDisplayLayout->addWidget(pImgLabel);
201 m_SmallGraphicDisplay->setLayout(smGraphicDisplayLayout);
202
203
204 // Get all user settings and preferences
205 {
206 m_Settings.beginGroup("/linguistica.uchicago.edu/Linguistica");
207
208 setMinimumSize(800, 600);
209 {
210 m_Settings.beginGroup("Geometry");
211 if (m_Settings.contains("Width") &&
212 m_Settings.contains("Height") &&
213 m_Settings.contains("X_Pos") &&
214 m_Settings.contains("Y_Pos")) {
215 QSize sz(m_Settings.value("Width").value<int>(),
216 m_Settings.value("Height").value<int>());
217 QPoint loc(m_Settings.value("X_Pos").value<int>(),
218 m_Settings.value("Y_Pos").value<int>());
219
220 resize(sz);
221 move(loc);
222 } else {
223 resize(sizeHint());
224 }
225 m_Settings.endGroup();
226 }
227
228 // Hack: ensure that if the window closed maximized, the next
229 // time it opens it will be maximized again and when
230 // un-maximized it will return to the last remembered
231 // un-maximized size and position.
232
233 // If the remembered position was large, the window
234 // probably closed maximized.
235 const bool maximized = QApplication::desktop()->width() < width()+10 ||
236 QApplication::desktop()->height() < height()+30;
237 if (maximized) {
238 {
239 m_Settings.beginGroup("Geometry");
240 if (m_Settings.contains("Width_Old") &&
241 m_Settings.contains("Height_Old") &&
242 m_Settings.contains("X_Pos_Old") &&
243 m_Settings.contains("Y_Pos_Old")) {
244 QSize sz(m_Settings.value("Width_Old").value<int>(),
245 m_Settings.value("Height_Old").value<int>());
246 QPoint loc(m_Settings.value("X_Pos_Old").value<int>(),
247 m_Settings.value("Y_Pos_Old").value<int>());
248
249 resize(sz);
250 move(loc);
251 }
252 m_Settings.endGroup();
253 }
254 showMaximized();
255 }
256
257 // Number of tokens
258 m_numberOfTokens = m_Settings.value(
259 "Lexicon/NumberOfTokens", 10000)
260 .value<int>();
261
262 // Set the triscreen dimensions
263 {
264 m_Settings.beginGroup("Triscreen");
265
266 if (m_Settings.contains("West") &&
267 m_Settings.contains("East") &&
268 m_Settings.contains("North") &&
269 m_Settings.contains("South")) {
270 QList<int> eastWest, northSouth;
271
272 // default: 300
273 eastWest.append(m_Settings.value("West").value<int>());
274 // default: 500
275 eastWest.append(m_Settings.value("East").value<int>());
276
277 // default: 400
278 northSouth.append(m_Settings.value("North").value<int>());
279 // default: 200
280 northSouth.append(m_Settings.value("South").value<int>());
281
282 m_eastWestSplitter->setSizes(eastWest);
283 m_northSouthSplitter->setSizes(northSouth);
284 }
285
286 m_Settings.endGroup();
287 }
288 m_Settings.endGroup();
289 }
290
291 {
292 // Connect signals and slots
293 connect(this, SIGNAL(updateAllViewsSignal()),
294 this, SLOT(updateTreeViewSlot()));
295 connect(this, SIGNAL(updateAllViewsSignal()),
296 this, SLOT(updateCollectionViewSlot()));
297 connect(this, SIGNAL(updateAllViewsSignal()),
298 this, SLOT(updateCommandLineSlot()));
299 connect(this, SIGNAL(updateCommandLineSignal()),
300 this, SLOT(updateCommandLineSlot()));
301 connect(this, SIGNAL(updateTreeViewSignal()),
302 this, SLOT(updateTreeViewSlot()));
303 connect(this, SIGNAL(tokensRequestedSignal()),
304 this, SLOT(tokensRequestedDialogSlot()));
305 }
306
307 // Draw tree view
308 m_treeView->setSortColumn(-1);
309 emit updateAllViewsSignal();
310
311 // Prepare collection view
312 m_collectionView->setShowSortIndicator(true);
313
314 // Command line execution
315 if (!args.corpus.isEmpty()) {
316 m_corpusFileName = args.corpus;
317
318 if (!args.logFile.isEmpty()) {
319 m_logging = true;
320 m_logFileName = args.logFile;
321 }
322
323 if (!args.goldStdFile.isEmpty())
324 m_goldStdFileName = args.goldStdFile;
325
326 if (!args.outputDir.isEmpty())
327 m_projectDirectory = args.outputDir;
328
329 executeCommandLineArgs(args.count, args.mini,
330 args.prefix, args.suffix);
331 return;
332 }
333 }
334
335 LinguisticaMainWindow::~LinguisticaMainWindow()
336 {
337 delete m_lexicon;
338 delete m_pSig1; // never used
339 delete m_pSig2; // never used
340 delete m_GUIWords; // never used
341 // close log file (flushes buffers)
342 delete m_logFile;
343 delete m_logFileStream;
344 delete m_progressDialog;
345 delete m_Words_InitialTemplates;
346 delete m_Words_Templates;
347 delete m_Sequencer;
348 delete m_Stats;
349 delete m_MT;
350 delete m_SmallCanvas;
351 delete m_SmallGraphicDisplayVBox; // never used
352 }
353
354 void LinguisticaMainWindow::enableLoggingActionSlot(bool b)
355 {
356 m_logging = b;
357 emit updateAllViewsSignal();
358 }
359
360
361 void LinguisticaMainWindow::clearLogFileActionSlot()
362 {
363 if( m_logFileStream )
364 {
365 // Log file open, can't clear now.
366 // TODO: message to screen.
367 return;
368 }
369
370 // Delete the file and create a new, empty one with
371 // the same name.
372 Q_ASSERT(!GetLogFileName().isEmpty());
373 m_logFile = new QFile( GetLogFileName() );
374 m_logFile->remove();
375 m_logFile = NULL;
376
377 OpenLogFile();
378 *m_logFileStream << "";
379 CloseLogFile();
380
381 emit updateAllViewsSignal();
382 }
383
384
385 void LinguisticaMainWindow::CloseLogFile()
386 {
387 if ( !m_logFileStream )
388 {
389 *GetLogFileStream() << "</body></html>";
390 Q_ASSERT ( !m_logging );
391 // AfxMessageBox ("Log file is not open."); // TODO: Qt
392 return;
393 }
394
395 Q_ASSERT ( m_logging );
396
397 m_logFile->close();
398 m_logFile = NULL;
399 m_logFileStream = NULL;
400 m_logging = FALSE;
401 }
402
403
404 void LinguisticaMainWindow::OpenLogFile()
405 {
406 if( m_logFileStream )
407 {
408 Q_ASSERT ( m_logging );
409 // AfxMessageBox ("Log file is already open."); // TODO: Qt
410 return;
411 }
412
413 if( GetLogFileName().lower() == "c:\\.txt" || GetLogFileName().lower() == "none" )
414 {
415 AskUserForLogFileName();
416 }
417
418 m_logFile = new QFile( GetLogFileName() );
419
420 if ( m_logFile->open( QIODevice::WriteOnly ) )
421 {
422 m_logFileStream = new QTextStream( m_logFile );
423 m_logFileStream->setEncoding( QTextStream::Unicode );
424 m_logging = TRUE;
425 *m_logFileStream << "<html><head> <meta http-equiv=\"content-type\" content=\"text/html; charset=ISO-8859-1\"/> <link rel=\"stylesheet\" type=\"text/css\" href=\"template_files/lxa.css\"/> <script charset=\"utf-8\" id=\"injection_graph_func\" src=\"template_files/injection_graph_func.js\"></script>";
426 *m_logFileStream << " <style type=\"text/css\">" ;
427 *m_logFileStream << " h1 { font-size: 250%; color: white; background-color: #1A4969; text-align: center;; font-family: Georgia, \"Times New Roman\", Times, serif }";
428 *m_logFileStream << " h2 { text-align: center; color: #0000FF; background-color: #E3DDAF ; font-size: 150%; margin-left:25%; margin-right:25%; }";
429 *m_logFileStream << " h3 { text-align: center; font-size: 120%; font-weight: bold; color: black; background-color: #21AD94 ; %border-top: thin solid #000000; border-bottom: thin solid #000000; margin-left: 0%; margin-right: 40%; padding: 0.3em; border-right: 1em solid black }" ;
430 *m_logFileStream << " h4 { text-align: center; font-size: 120%; color: #000000; background-color: #21AD94 ; padding: 5px; height: auto; border-left: 1em solid black; %border: thin solid #FF0000; %margin-top: 5px; %margin-bottom: 5px; margin-left: 40%; }" ;
431 *m_logFileStream << " h5 { color: #FF0000; background-color: #EEEEEE; font-size: 80%; text-align: center; }" ;
432 *m_logFileStream << " table { border-width: 4px 4px 4px 4px; border-spacing: 2px; border-style: outset outset outset outset; border-color: #1A4969 #1A4969 #1A4969 #1A4969; border-collapse: separate; background-color: rgb(255, 255, 255); margin-left: auto; margin-right: auto; margin-top: 2em; }";
433 *m_logFileStream << "table th { border-width: 1px 1px 1px 1px; padding: 2px 2px 2px 2px; border-style: solid solid solid solid; border-color: gray gray gray gray; background-color: white; -moz-border-radius: 3px 3px 3px 3px; }" ;
434 *m_logFileStream << " h4 { table td { border-width: 1px 1px 1px 1px; padding: 2px 2px 2px 2px; border-style: solid solid solid solid; border-color: gray gray gray gray; background-color: white; -moz-border-radius: 3px 3px 3px 3px; }" ;
435 *m_logFileStream << "</style></head><body>";
436
437
438
439 }
440
441 return;
442 }
443
444
445 void LinguisticaMainWindow::newLogFileActionSlot()
446 {
447 AskUserForLogFileName();
448 emit updateAllViewsSignal();
449 }
450
451
452 void LinguisticaMainWindow::runAllSuffixActionSlot()
453 {
454 if( m_lexicon->GetMiniCount() )
455 {
456 // Run all suffix functions, log if desired
457 if( m_logging ) OpenLogFile();
458 m_lexicon->FindSuffixes();
459 if( m_logging ) CloseLogFile();
460
461 // Update corpus words
462 m_lexicon->DoWordUpdates();
463
464
465 // Enable allomorphy
466 // findAllomorphyAction->setEnabled(true);
467
468 // Unsaved work
469 m_projectDirty = true;
470
471 // Update tree view
472 emit updateAllViewsSignal();
473 }
474 }
475
476
477 void LinguisticaMainWindow::runAllPrefixActionSlot()
478 {
479 if( m_lexicon->GetMiniCount() )
480 {
481 // Run all prefix functions, log if desired
482 if( m_logging ) OpenLogFile();
483 m_lexicon->FindPrefixes();
484 if( m_logging ) CloseLogFile();
485
486 // Update corpus words
487 m_lexicon->DoWordUpdates();
488
489 // Unsaved work
490 m_projectDirty = true;
491
492 // Update tree view
493 emit updateAllViewsSignal();
494 }
495 }
496
497
498 void LinguisticaMainWindow::AskUserForLogFileName()
499 {
500 bool ok;
501
502 QString lastfile = m_Settings.readEntry( "/linguistica.uchicago.edu/Linguistica/MainWindow/LogFile/FileName", QString::null, &ok );
503 m_logFileName = Q3FileDialog::getSaveFileName( lastfile,
504 "Text Files( *.txt );;Rich Text Files( *.rtf );;All Files( *.* )",
505 this,
506 "Open Log File" );
507 if( !m_logFileName.isEmpty() && lastfile != m_logFileName )
508 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/MainWindow/LogFile/FileName", m_logFileName );
509 }
510
511
512 // Change font in collection view and command line only
513 void LinguisticaMainWindow::changeFontSlot()
514 {
515 bool ok;
516 QFont font = QFontDialog::getFont( &ok, m_eastFont, this );
517 if ( ok )
518 {
519 // Apply this font to the collection view and
520 // command line frames
521 m_eastFont = font;
522 font = GetFontPreference( "Affix" );
523 font.setFamily( m_eastFont.family() );
524 font.setPointSize( m_eastFont.pointSize() );
525 SetFontPreference( "Affix", font );
526
527 font = GetFontPreference( "Signature" );
528 font.setFamily( m_eastFont.family() );
529 font.setPointSize( m_eastFont.pointSize() );
530 SetFontPreference( "Signature", font );
531
532 font = GetFontPreference( "Stem" );
533 font.setFamily( m_eastFont.family() );
534 font.setPointSize( m_eastFont.pointSize() );
535 SetFontPreference( "Stem", font );
536
537 font = GetFontPreference( "Word" );
538 font.setFamily( m_eastFont.family() );
539 font.setPointSize( m_eastFont.pointSize() );
540 SetFontPreference( "Word", font );
541
542 emit updateAllViewsSignal();
543 }
544 else
545 {
546 // the user canceled the dialog; font is set
547 // to the application's default font
548 }
549 }
550
551 // Called before closing the main window
552 void LinguisticaMainWindow::closeEvent(QCloseEvent* close)
553 {
554 if (m_commandLineFlag) {
555 close->accept();
556 return;
557 }
558
559 bool verify;
560
561 // Record triscreen position before closing
562 Q3ValueList<int> eastWest = m_eastWestSplitter->sizes(),
563 northSouth = m_northSouthSplitter->sizes();
564
565 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Triscreen/West", eastWest.first() );
566 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Triscreen/East", eastWest.last() );
567 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Triscreen/North", northSouth.first() );
568 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Triscreen/South", northSouth.last() );
569
570 // Verify information saved
571 QString notifications = GetPreference( "Notifications" );
572 if( notifications.length() ) verify = GetPreference( "Notifications" ).toInt();
573 else verify = false;
574
575 if ( verify && m_projectDirty ) {
576 QString message = "Would you like to save your changes before closing?";
577 VerifyDialog *saveCheckDlg = new VerifyDialog(message);
578 saveCheckDlg->setCaption( saveCheckDlg->caption() + "Save Project?" );
579
580 switch( saveCheckDlg->exec() )
581 {
582 case RESULT_YES:
583 // User clicked 'Yes', save changes and close
584 saveFileActionSlot();
585 if ( m_projectDirty ) close->ignore();
586 else close->accept();
587 return;
588 case RESULT_NO:
589 // User clicked 'No', close without saving
590 close->accept();
591 return;
592 case RESULT_CANCEL:
593 default:
594 // User clicked 'Cancel', do not close
595 close->ignore();
596 return;
597 }
598 }
599
600 // allow the window to close
601 close->accept();
602 }
603
604
605 // Called whenever the window is resized, includes maximizing,
606 // normalizing, opening and closing the window
607 void LinguisticaMainWindow::resizeEvent( QResizeEvent *resize )
608 {
609 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Geometry/Width", resize->size().width() );
610 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Geometry/Height", resize->size().height() );
611
612 // If old size and new size are different, update old size
613 if( resize->size().width() != resize->oldSize().width() )
614 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Geometry/Width_Old", resize->oldSize().width() );
615 if( resize->size().width() != resize->oldSize().width() )
616 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Geometry/Height_Old", resize->oldSize().height() );
617 }
618
619
620 // Called whenever the window is moved, includes maximizing,
621 // normalizing, opening and closing the window
622 void LinguisticaMainWindow::moveEvent( QMoveEvent *move )
623 {
624 int x, y;
625 int x_max = QApplication::desktop()->width() - ( width() + 10 );
626 int y_max = QApplication::desktop()->height() - ( height() + 30 );
627 x = move->pos().x();
628 if( x < 10 ) x = 10;
629 if( x > x_max ) x = x_max;
630 y = move->pos().y();
631 if( y < 30 ) y = 30;
632 if( y > y_max ) y = y_max;
633
634 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Geometry/X_Pos", x );
635 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Geometry/Y_Pos", y );
636
637 // If old position and new position are different, update old position.
638 if( move->pos().x() != move->oldPos().x() || move->pos().y() != move->oldPos().y() )
639 {
640 x = move->oldPos().x();
641 if( x < 10 ) x = 10;
642 if( x > x_max ) x = x_max;
643 y = move->oldPos().y();
644 if( y < 30 ) y = 30;
645 if( y > y_max ) y = y_max;
646
647 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Geometry/X_Pos_Old", x );
648 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Geometry/Y_Pos_Old", y );
649 }
650 }
651
652 void LinguisticaMainWindow::tokensRequestedDialogSlot()
653 {
654 bool ok;
655 int amount = QInputDialog::getInteger(this, "Linguistica",
656 "Number of tokens requested:", m_numberOfTokens,
657 0, std::numeric_limits<int>::max(), 1, &ok);
658
659 if (!ok || amount == 0)
660 // user cancelled
661 return;
662
663 // user entered something and pressed OK
664 m_numberOfTokens = amount;
665 m_Settings.writeEntry("/linguistica.uchicago.edu/Linguistica/"
666 "Lexicon/NumberOfTokens", amount);
667
668 m_collectionView->clear();
669 m_docType = NO_DOC;
670 emit updateTreeViewSignal();
671 }
672
673 void LinguisticaMainWindow::setStatusBar1(QString string)
674 {
675 if (m_progressText1 == string) return;
676 m_progressText1 = string;
677 m_status->major_operation = string;
678 }
679
680
681 void LinguisticaMainWindow::setStatusBar2(QString string)
682 {
683 if (m_progressText2 == string) return;
684 m_progressText2 = string;
685 m_status->details = string;
686 }
687
688
689 void LinguisticaMainWindow::BeginCountDown()
690 {
691 m_status->progress.clear();
692 }
693
694
695 void LinguisticaMainWindow::EndCountDown()
696 {
697 m_status->progress.clear();
698
699 m_progressText1 = "";
700 m_progressText2 = "";
701 }
702
703
704 void LinguisticaMainWindow::CountDownOnStatusBar( int i, int total, int stepsize )
705 {
706 if (stepsize == 0)
707 stepsize = total/100;
708 if (stepsize < 1)
709 stepsize = 1;
710
711 if (i < 0 || i > total)
712 m_status->progress.clear();
713 else
714 // Update on multiples of stepsize
715 if (i % stepsize == 0) {
716 m_status->progress.set_denominator(total);
717 m_status->progress = i;
718 }
719 }
720
721
722 void LinguisticaMainWindow::newFileActionSlot()
723 {
724 bool ok;
725 int result;
726
727 // Verify information saved before overwrite
728 bool notifications = GetPreference( "Notifications" ).toInt();
729 if( notifications && m_projectDirty )
730 {
731 QString message = "This action will overwrite your data. Would you like to\nsave your changes first?";
732 VerifyDialog *saveCheckDlg = new VerifyDialog(message);
733 saveCheckDlg->setCaption( saveCheckDlg->caption() + "Save Project?" );
734
735 switch( saveCheckDlg->exec() )
736 {
737 case RESULT_YES:
738 // User clicked 'Yes', save changes and continue
739 saveFileActionSlot();
740 if( m_projectDirty ) return;
741 break;
742 case RESULT_NO:
743 // User clicked 'No', continue
744 break;
745 case RESULT_CANCEL:
746 default:
747 // User clicked 'Cancel', just return
748 return;
749 }
750 }
751
752
753 // Dialog for lexicon file
754 QString lastfile = m_Settings.readEntry( "/linguistica.uchicago.edu/Linguistica/MainWindow/FileMenu/Open", QString::null, &ok );
755 QString filename = Q3FileDialog::getOpenFileName( lastfile, "Text Files( *.txt );;Rich Text Files( *.rtf );;All Files( *.* )" );
756 if( !filename.isEmpty() ){
757 if( lastfile != filename ) m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/MainWindow/FileMenu/Open", filename );
758
759 m_corpusFileName = filename;
760
761 // Read the lexicon and activate other functions
762 // if successful. Log if desired.
763 m_lexicon->ClearAll();
764 if( m_logging ) OpenLogFile();
765 result = m_lexicon->ReadCorpus( filename, GetNumberOfTokens() );
766 if( m_logging ) CloseLogFile();
767 if( result != -1 )
768 {
769 // runAllAction->setEnabled(true);
770 rereadCorpusAction->setEnabled( true );
771 }
772 else
773 {
774 // if( runAllAction->isEnabled() ) runAllAction->setEnabled(false);
775 if( rereadCorpusAction->isEnabled() ) rereadCorpusAction->setEnabled(false);
776 }
777
778 // Update corpus words
779 m_lexicon->DoWordUpdates();
780
781 // Project unsaved
782 m_projectDirty = true;
783 }
784
785 // Set the filter for graphic display and anything else if necessary
786 m_SmallGraphicDisplay->SetFilter( m_lexicon->GetOutFilter() );
787
788 // Clear the collection view
789 m_collectionView->clear();
790 m_docType = NO_DOC;
791
792 // Update tree view
793 emit updateAllViewsSignal();
794 }
795
796
797 void LinguisticaMainWindow::SetUpNewLexicon()
798 {
799 // int count = m_lexicon->GetNumberOfWords();
800 delete m_lexicon;
801 m_lexicon = new CLexicon(this);
802 // m_lexicon->SetNumberOfWords( count );
803
804 QStringList items;
805 GetStringListPreference( "Character_Combinations", &items );
806 m_lexicon->SetFilters( &items );
807 }
808
809
810 void LinguisticaMainWindow::openFileActionSlot()
811 {
812 QString Directory,
813 ProjectName,
814 ProjectFileName,
815 FileName,
816 CorpusFileName;
817 int SlashLoc, DotLoc, i, j;
818
819 CMiniLexicon* mini;
820
821 SetUpNewLexicon();
822
823 CorpusFileName = Q3FileDialog::getOpenFileName( m_projectDirectory,
824 "Project files (*.prj);;All files (*.*)",
825 this,
826 "open file dialog",
827 "Choose a project to open" );
828
829 if( CorpusFileName != QString::null )
830 {
831 SlashLoc = CorpusFileName.findRev ('\\');
832 if( SlashLoc < 0 ) SlashLoc = CorpusFileName.findRev('/');
833 Directory = CorpusFileName.left( SlashLoc + 1 );
834
835 setProjectDirectory( Directory );
836
837 FileName = CorpusFileName.mid (SlashLoc+1);
838 DotLoc = FileName.findRev ('.');
839 if( DotLoc < 0 ) return;
840
841 ProjectName = FileName.left(DotLoc);
842 ProjectFileName = Directory + ProjectName + ".prj";
843
844 int miniCount = m_lexicon->ReadProjectFile( ProjectFileName );
845
846 for( i=0; i < miniCount; i++ )
847 {
848 j = m_lexicon->NewMiniLexicon();
849 Q_ASSERT( j == i );
850 mini = m_lexicon->GetMiniLexicon(i);
851
852 QString Prefix = Directory + ProjectName + "_";
853 QString SuffixFileName = Prefix + QString("Mini%1_").arg(i+1) + "Suffixes.txt";
854 QString PrefixFileName = Prefix + QString("Mini%1_").arg(i+1) + "Prefixes.txt";
855 QString SignatureFileName = Prefix + QString("Mini%1_").arg(i+1) + "Signatures.txt";
856 QString StemFileName = Prefix + QString("Mini%1_").arg(i+1) + "Stems.txt";
857 QString WordFileName = Prefix + QString("Mini%1_").arg(i+1) + "Words.txt";
858
859 setStatusBar1( "Reading suffixes..." );
860 mini->GetSuffixes()->ReadSuffixFile( SuffixFileName );// must precede signatures Oct 20 1999 jg
861
862 if( mini && mini->GetSuffixes()->GetCount() == 0 )
863 {
864 mini->SetAffixLocation( STEM_INITIAL );
865 setStatusBar1( "Reading prefixes..." );
866 mini->GetPrefixes()->ReadPrefixFile( PrefixFileName );// must precede signatures Oct 20 1999 jg
867 }
868
869 setStatusBar1( "Reading signatures..." );
870 mini->GetSignatures()->ReadSignatureFile( SignatureFileName, mini->GetAffixLocation() ); // must follow suffixes
871
872 setStatusBar1( "Reading stems..." );
873 mini->GetStems()->ReadStemFile( StemFileName, mini->GetAffixLocation() ); //stems must follow signatures Oct 24 1999 jg, but also must precede signatures for signatures to get their stem lists...too bad.
874
875 setStatusBar1 ( "Reading signatures (verbose)..." );
876 mini->GetSignatures()->ReadSignatureFileBis(SignatureFileName);
877
878 setStatusBar1 ( "Reading words..." );
879 mini->GetWords()->ReadWordFile( WordFileName );
880 }
881
882 // TODO: read corpus words
883
884 setStatusBar1 ( "" );
885
886 emit updateAllViewsSignal();
887 }
888 }
889
890
891 void LinguisticaMainWindow::saveAsFileActionSlot()
892 {
893
894 int SlashLoc;
895 int NameLoc;
896
897 // Notify about large number of files
898 bool notify;
899 QString notifications = GetPreference( "Notifications" );
900 if( notifications.length() ) notify = GetPreference( "Notifications" ).toInt();
901 else notify = true;
902
903 if( notify )
904 {
905 QString message = "Linguistica saves your project in a large number of 'readable' text\nfiles. We suggest you create a new folder in which to save them.";
906 QMessageBox::information ( this, "Linguistica : Save File", message );
907 }
908
909 QString FileName = Q3FileDialog::getSaveFileName( m_projectDirectory + m_projectName,
910 "Linguistica Projects (*.prj)",
911 this,
912 "save file dialog"
913 "Choose a folder to save under" );
914
915 if (FileName.length() == 0 ) return;
916
917 SlashLoc = FileName.findRev ('\\');
918 if( SlashLoc < 0 ) SlashLoc = FileName.findRev('/');
919 m_projectIndex = 1;
920
921 m_projectDirectory = FileName.left( SlashLoc + 1 );
922 m_Settings.writeEntry( "/linguistica.uchicago.edu/Linguistica/Project/Directory", m_projectDirectory );
923
924 m_projectName = FileName.mid ( SlashLoc + 1 );
925 NameLoc = m_projectName.findRev(".prj");
926 SlashLoc = m_projectName.findRev("_");
927 if( NameLoc >= 0 )
928 {
929 if( SlashLoc >= 0 && SlashLoc < NameLoc )
930 {
931 FileName = m_projectName.mid( SlashLoc + 1, NameLoc - SlashLoc - 1 );
932 m_projectIndex = FileName.toInt();
933 m_projectName = m_projectName.left( SlashLoc );
934 }
935 else
936 {
937 m_projectName = m_projectName.left( NameLoc );
938 }
939 }
940
941 //saveFileActionSlot(); //removed so I can use in Xfst function -sw
942
943 }
944
945
946 void LinguisticaMainWindow::saveFileActionSlot()
947 {
948 if ( m_projectDirectory.length() == 0 || m_projectName.length() == 0 )
949 {
950 saveAsFileActionSlot();
951 //return; //changed flow, control returns to this func -sw
952 }
953
954 QString Prefix = m_projectDirectory + m_projectName + "_" + QString("%1").arg( m_projectIndex );
955 m_projectIndex ++;
956 QString ProjectFileName = Prefix + ".prj";
957
958 for( int i=0; i < m_lexicon->GetMiniSize(); i++ )
959 {
960 CMiniLexicon* mini = m_lexicon->GetMiniLexicon(i);
961 if( !mini ) continue;
962
963 QString WordsFileName = Prefix + QString("_Mini%1").arg(i+1) + "_Words.txt";
964
965 QString SuffixFileName = Prefix + QString("_Mini%1").arg(i+1) + "_Suffixes.txt";
966 QString PrefixFileName = Prefix + QString("_Mini%1").arg(i+1) + "_Prefixes.txt";
967
968 QString SignatureFileName = Prefix + QString("_Mini%1").arg(i+1) + "_Signatures.txt";
969 QString StemFileName = Prefix + QString("_Mini%1").arg(i+1) + "_Stems.txt";
970
971 mini->GetWords()->OutputWords(WordsFileName,
972 m_lexicon->GetOutFilter());
973
974 if( mini->GetAffixLocation() == WORD_FINAL ||
975 mini->GetAffixLocation() == STEM_FINAL )
976 {
977 mini->GetSuffixes()->OutputSuffixes( SuffixFileName );
978 }
979
980 if( mini->GetAffixLocation() == WORD_INITIAL ||
981 mini->GetAffixLocation() == STEM_INITIAL )
982 {
983 mini->GetPrefixes()->OutputPrefixes( PrefixFileName );
984 }
985
986 if( mini->GetSignatures() )
987 {
988 mini->GetSignatures()->OutputSignatures( SignatureFileName );
989 mini->GetStems()->OutputStems(StemFileName,
990 m_lexicon->GetOutFilter());
991 }
992
993 }
994
995 m_lexicon->OutputStats( ProjectFileName );
996
997 // TODO: output corpus words
998
999 // Project saved
1000 m_projectDirty = false;
1001
1002 emit updateTreeViewSignal();
1003 }
1004
1005 void LinguisticaMainWindow::xfstExportActionSlot()
1006 {
1007 if ( m_projectDirectory.length() == 0 || m_projectName.length() == 0 )
1008 saveAsFileActionSlot(); //get project dir and name
1009
1010 QString Prefix = m_projectDirectory + m_projectName + "_" + QString("%1").arg( m_projectIndex );
1011
1012 for( int i=0; i < m_lexicon->GetMiniSize(); i++ )
1013 {
1014 CMiniLexicon* mini = m_lexicon->GetMiniLexicon(i);
1015 if( mini && mini->GetSignatures() )
1016 {
1017 QString XfstFileName = Prefix + QString("_Mini%1").arg(i+1) + ".xfst";
1018 mini->GetSignatures()->OutputXfst( XfstFileName );
1019 mini->GetFSA()->OutputFSAXfst(Prefix+"_FSA.xfst");
1020 }
1021 }
1022 }
1023
1024
1025 namespace {
1026 // "c:\\Program Files\\Internet Explorer\\iexplore.exe" on Windows?
1027 const QString default_browser = "netscape";
1028 }
1029
1030 void LinguisticaMainWindow::jgWebLinksActionSlot()
1031 {
1032 // code taken from a Qt message board -jeremy
1033 QString url = "http://humanities.uchicago.edu/faculty/goldsmith";
1034 Q3Process *browser = new Q3Process( this );
1035 browser->clearArguments();
1036 browser->addArgument(default_browser);
1037
1038 if(url.stripWhiteSpace().length() > 0)
1039 {
1040 browser->addArgument(url);
1041 }
1042 if( !browser->start() )
1043 {
1044 QMessageBox::critical(this, "Critical!",
1045 "Browser reports error!");
1046 }
1047 }
1048
1049
1050 void LinguisticaMainWindow::lxaWebLinksActionSlot()
1051 {
1052 // code taken from a Qt message board -jeremy
1053 QString url = "http://linguistica.uchicago.edu/linguistica.html";
1054 Q3Process *browser = new Q3Process( this );
1055 browser->clearArguments();
1056 browser->addArgument(default_browser);
1057
1058 if(url.stripWhiteSpace().length() > 0)
1059 {
1060 browser->addArgument(url);
1061 }
1062 if( !browser->start() )
1063 {
1064 QMessageBox::critical(this, "Critical!",
1065 "Browser reports error!");
1066 }
1067 }
1068
1069
1070
1071 void LinguisticaMainWindow::findAllomorphySlot()
1072 {
1073 if( m_lexicon->GetMiniCount() )
1074 {
1075
1076 if( m_logging ) OpenLogFile();
1077 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1078
1079 current_mini->RelateStems();
1080
1081
1082
1083 // m_lexicon->FindAllomorphy();
1084 // m_lexicon->FindAllomorphy2();
1085 if( m_logging ) CloseLogFile();
1086
1087 // Update corpus words
1088 m_lexicon->DoWordUpdates();
1089
1090 // Disable this functionality
1091 // if( findAllomorphyAction->isEnabled() ) findAllomorphyAction->setEnabled(false);
1092
1093 // Unsaved work
1094 m_projectDirty = true;
1095
1096 // Update tree view
1097 emit updateAllViewsSignal();
1098
1099 }
1100 }
1101
1102
1103 void LinguisticaMainWindow::showDeleteesSlot( bool b )
1104 {
1105 m_showDeleteesAction->setOn( b );
1106 emit updateAllViewsSignal();
1107 }
1108
1109
1110 void LinguisticaMainWindow::rereadCorpusSlot()
1111 {
1112 int result;
1113
1114 if (m_corpusFileName.isEmpty()) {
1115 // XXX. no corpus file chosen! let user know.
1116 return;
1117 }
1118
1119 // Verify information saved before overwrite
1120 bool notifications = GetPreference( "Notifications" ).toInt();
1121 if( notifications && m_projectDirty )
1122 {
1123 QString message = "This action will overwrite your data. Would you like to\nsave your changes first?";
1124 VerifyDialog *saveCheckDlg = new VerifyDialog(message);
1125 saveCheckDlg->setCaption( saveCheckDlg->caption() + "Save Project?" );
1126
1127 switch( saveCheckDlg->exec() )
1128 {
1129 case RESULT_YES:
1130 // User clicked 'Yes', save changes and continue
1131 saveFileActionSlot();
1132 if( m_projectDirty ) return;
1133 break;
1134 case RESULT_NO:
1135 // User clicked 'No', continue
1136 break;
1137 case RESULT_CANCEL:
1138 default:
1139 // User clicked 'Cancel', just return
1140 return;
1141 }
1142 }
1143
1144 // Clear collection view
1145 m_collectionView->clear();
1146 m_docType = NO_DOC;
1147
1148 // Read the lexicon and activate other functions
1149 // if successful. Log if desired.
1150 if( m_logging ) OpenLogFile();
1151 Q_ASSERT(!m_corpusFileName.isEmpty());
1152 result = m_lexicon->RereadCorpus( m_corpusFileName, GetNumberOfTokens() );
1153 if( m_logging ) CloseLogFile();
1154 // if( result != -1 ) runAllAction->setEnabled(true);
1155 // else if( runAllAction->isEnabled() ) runAllAction->setEnabled(false);
1156
1157 // Set the filter for graphic display and anything else if necessary
1158 m_SmallGraphicDisplay->SetFilter( m_lexicon->GetOutFilter() );
1159
1160 // Update corpus words
1161 m_lexicon->DoWordUpdates();
1162
1163 // Project unsaved
1164 m_projectDirty = true;
1165
1166 emit updateAllViewsSignal();
1167 }
1168
1169
1170 void LinguisticaMainWindow::clearLexiconSlot()
1171 {
1172 // Verify information saved before overwrite
1173 bool notifications = GetPreference( "Notifications" ).toInt();
1174 if( notifications && m_projectDirty )
1175 {
1176 QString message = "This action will overwrite your data. Would you like to\nsave your changes first?";
1177 VerifyDialog *saveCheckDlg = new VerifyDialog(message);
1178 saveCheckDlg->setCaption( saveCheckDlg->caption() + "Save Project?" );
1179
1180 switch( saveCheckDlg->exec() )
1181 {
1182 case RESULT_YES:
1183 // User clicked 'Yes', save changes and continue
1184 saveFileActionSlot();
1185 if( m_projectDirty ) return;
1186 break;
1187 case RESULT_NO:
1188 // User clicked 'No', continue
1189 break;
1190 case RESULT_CANCEL:
1191 default:
1192 // User clicked 'Cancel', just return
1193 return;
1194 }
1195 }
1196
1197 m_collectionView->clear();
1198 m_docType = NO_DOC;
1199 m_lexicon->ClearAll();
1200 m_projectDirty = false;
1201 emit updateAllViewsSignal();
1202 }
1203
1204
1205 void LinguisticaMainWindow::successorFreqSlot()
1206 {
1207 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1208
1209 if( m_lexicon->GetMiniCount() )
1210 {
1211 if( isCorrectAffix( STEM_FINAL ) )
1212 {
1213
1214 // Run successor freq function, log if desired
1215 if( m_logging ) OpenLogFile();
1216 current_mini->GetWords()->SuccessorFreq1(
1217 current_mini->GetStems(),
1218 current_mini->GetSuffixes(),
1219 current_mini->GetSignatures(), SF1,
1220 CStem::NUMBER | CStem::UNKNOWN);
1221 if( m_logging ) CloseLogFile();
1222
1223 // Update corpus words
1224 m_lexicon->DoWordUpdates();
1225
1226 // Unsaved work
1227 m_projectDirty = true;
1228
1229 // Update tree view
1230 emit updateAllViewsSignal();
1231 }
1232 else
1233 {
1234 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1235 new_mini->SetAffixLocation( STEM_FINAL );
1236 new_mini->AddToWordCollection(current_mini->GetWords(),
1237 CMiniLexicon::WW_All);
1238 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1239 successorFreqSlot();
1240 }
1241 }
1242 }
1243
1244
1245 void LinguisticaMainWindow::predecessorFreqSlot()
1246 {
1247 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1248
1249 if( m_lexicon->GetMiniCount() )
1250 {
1251 if( isCorrectAffix( STEM_INITIAL ) )
1252 {
1253
1254 // Run predecessor freq function, log if desired
1255 if( m_logging ) OpenLogFile();
1256 current_mini->GetWords()->CreateReverseTrie();
1257 current_mini->GetWords()->PredecessorFreq1(
1258 current_mini->GetStems(),
1259 current_mini->GetPrefixes(),
1260 current_mini->GetSignatures(),
1261 SF1,
1262 CStem::NUMBER | CStem::UNKNOWN);
1263 if( m_logging ) CloseLogFile();
1264
1265 // Update corpus words
1266 m_lexicon->DoWordUpdates();
1267
1268 // Unsaved work
1269 m_projectDirty = true;
1270
1271 // Update tree view
1272 emit updateAllViewsSignal();
1273 }
1274 else
1275 {
1276 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1277 new_mini->SetAffixLocation( STEM_INITIAL );
1278 new_mini->AddToWordCollection(current_mini->GetWords(),
1279 CMiniLexicon::WW_All);
1280 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1281 predecessorFreqSlot();
1282 }
1283 }
1284 }
1285
1286
1287 void LinguisticaMainWindow::checkPfxSignaturesSlot()
1288 {
1289 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1290
1291 if( m_lexicon->GetMiniCount() )
1292 {
1293 if( isCorrectAffix( STEM_INITIAL ) )
1294 {
1295
1296 // Run successor freq function, log if desired
1297 if( m_logging ) OpenLogFile();
1298 current_mini->CheckSignatures();
1299
1300 if( m_logging ) CloseLogFile();
1301
1302 // Update corpus words
1303 m_lexicon->DoWordUpdates();
1304
1305 // Unsaved work
1306 m_projectDirty = true;
1307
1308 // Update tree view
1309 emit updateAllViewsSignal();
1310 }
1311 else
1312 {
1313 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1314 new_mini->SetAffixLocation( STEM_INITIAL );
1315 new_mini->AddToWordCollection(current_mini->GetWords(),
1316 CMiniLexicon::WW_All);
1317 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1318 checkPfxSignaturesSlot();
1319 }
1320 }
1321 }
1322
1323 void LinguisticaMainWindow::checkSignaturesSlot()
1324 {
1325 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1326
1327 if( m_lexicon->GetMiniCount() )
1328 {
1329 if( isCorrectAffix( STEM_FINAL ) )
1330 {
1331
1332 // Run successor freq function, log if desired
1333 if( m_logging ) OpenLogFile();
1334 m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex())->CheckSignatures();
1335
1336 if( m_logging ) CloseLogFile();
1337
1338 // Update corpus words
1339 // m_lexicon->DoWordUpdates();
1340
1341 // Unsaved work
1342 m_projectDirty = true;
1343
1344 // Update tree view
1345 emit updateAllViewsSignal();
1346 }
1347 else
1348 {
1349 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1350 new_mini->SetAffixLocation( STEM_FINAL );
1351 new_mini->AddToWordCollection(current_mini->GetWords(),
1352 CMiniLexicon::WW_All);
1353 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1354 checkSignaturesSlot();
1355 }
1356 }
1357 }
1358
1359 void LinguisticaMainWindow::knownStemsPrefixesSlot()
1360 {
1361 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1362
1363 if( m_lexicon->GetMiniCount() )
1364 {
1365 if( isCorrectAffix( STEM_INITIAL ) )
1366 {
1367
1368 // Run successor freq function, log if desired
1369 if( m_logging ) OpenLogFile();
1370 current_mini->ExtendKnownStemsToKnownAffixes();
1371
1372 if( m_logging ) CloseLogFile();
1373
1374 // Update corpus words
1375 m_lexicon->DoWordUpdates();
1376
1377 // Unsaved work
1378 m_projectDirty = true;
1379
1380 // Update tree view
1381 emit updateAllViewsSignal();
1382 }
1383 else
1384 {
1385 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1386 new_mini->SetAffixLocation( STEM_INITIAL );
1387 new_mini->AddToWordCollection(current_mini->GetWords(),
1388 CMiniLexicon::WW_All);
1389 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1390 knownStemsPrefixesSlot();
1391 }
1392 }
1393 }
1394
1395
1396 void LinguisticaMainWindow::knownStemsSuffixesSlot()
1397 {
1398 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1399
1400 if( m_lexicon->GetMiniCount() )
1401 {
1402 if( isCorrectAffix( STEM_FINAL ) )
1403 {
1404
1405 // Run successor freq function, log if desired
1406 if( m_logging ) OpenLogFile();
1407 current_mini->ExtendKnownStemsToKnownAffixes();
1408
1409 if( m_logging ) CloseLogFile();
1410
1411 // Update corpus words
1412 m_lexicon->DoWordUpdates();
1413
1414 // Unsaved work
1415 m_projectDirty = true;
1416
1417 // Update tree view
1418 emit updateAllViewsSignal();
1419 }
1420 else
1421 {
1422 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1423 new_mini->SetAffixLocation( STEM_FINAL );
1424 new_mini->AddToWordCollection(current_mini->GetWords(),
1425 CMiniLexicon::WW_All);
1426 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1427 knownStemsSuffixesSlot();
1428 }
1429 }
1430 }
1431
1432 void LinguisticaMainWindow::fromPfxSigsFindStemsSlot()
1433 {
1434 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1435
1436 if( m_lexicon->GetMiniCount() )
1437 {
1438 if( isCorrectAffix( STEM_INITIAL ) )
1439 {
1440
1441 // Run successor freq function, log if desired
1442 if( m_logging ) OpenLogFile();
1443 current_mini->TakeSignaturesFindStems();
1444
1445 if( m_logging ) CloseLogFile();
1446
1447 // Update corpus words
1448 m_lexicon->DoWordUpdates();
1449
1450 // Unsaved work
1451 m_projectDirty = true;
1452
1453 // Update tree view
1454 emit updateAllViewsSignal();
1455 }
1456 else
1457 {
1458 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1459 new_mini->SetAffixLocation( STEM_INITIAL );
1460 new_mini->AddToWordCollection(current_mini->GetWords(),
1461 CMiniLexicon::WW_All);
1462 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1463 fromPfxSigsFindStemsSlot();
1464 }
1465 }
1466 }
1467
1468
1469 void LinguisticaMainWindow::fromSigsFindStemsSlot()
1470 {
1471 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1472
1473 if( m_lexicon->GetMiniCount() )
1474 {
1475 if( isCorrectAffix( STEM_FINAL ) )
1476 {
1477
1478 // Run successor freq function, log if desired
1479 if( m_logging ) OpenLogFile();
1480 current_mini->TakeSignaturesFindStems();
1481
1482 if( m_logging ) CloseLogFile();
1483
1484 // Update corpus words
1485 m_lexicon->DoWordUpdates();
1486
1487 // Unsaved work
1488 m_projectDirty = true;
1489
1490 // Update tree view
1491 emit updateAllViewsSignal();
1492 }
1493 else
1494 {
1495 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1496 new_mini->SetAffixLocation( STEM_FINAL );
1497 new_mini->AddToWordCollection(current_mini->GetWords(),
1498 CMiniLexicon::WW_All);
1499 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1500 fromSigsFindStemsSlot();
1501 }
1502 }
1503 }
1504
1505
1506 void LinguisticaMainWindow::fromStemsFindAffixesSlot()
1507 {
1508 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1509
1510 if( m_lexicon->GetMiniCount() )
1511 {
1512 if( isCorrectAffix( STEM_FINAL ) )
1513 {
1514
1515 // Run successor freq function, log if desired
1516 if( m_logging ) OpenLogFile();
1517 current_mini->FromStemsFindAffixes();
1518
1519 if( m_logging ) CloseLogFile();
1520
1521 // Update corpus words
1522 m_lexicon->DoWordUpdates();
1523
1524 // Unsaved work
1525 m_projectDirty = true;
1526
1527 // Update tree view
1528 emit updateAllViewsSignal();
1529 }
1530 else
1531 {
1532 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1533 new_mini->SetAffixLocation( STEM_FINAL );
1534 new_mini->AddToWordCollection(current_mini->GetWords(),
1535 CMiniLexicon::WW_All);
1536 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1537 fromStemsFindAffixesSlot();
1538 }
1539 }
1540 }
1541
1542
1543 void LinguisticaMainWindow::findPfxSingletonSigsSlot()
1544 {
1545 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1546
1547 if( m_lexicon->GetMiniCount() )
1548 {
1549 if( isCorrectAffix( STEM_INITIAL ) )
1550 {
1551
1552 // Run successor freq function, log if desired
1553 if( m_logging ) OpenLogFile();
1554 current_mini->FindSingletonSignatures();
1555
1556 if( m_logging ) CloseLogFile();
1557
1558 // Update corpus words
1559 m_lexicon->DoWordUpdates();
1560
1561 // Unsaved work
1562 m_projectDirty = true;
1563
1564 // Update tree view
1565 emit updateAllViewsSignal();
1566 }
1567 else
1568 {
1569 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1570 new_mini->SetAffixLocation( STEM_INITIAL );
1571 new_mini->AddToWordCollection(current_mini->GetWords(),
1572 CMiniLexicon::WW_All);
1573 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1574 findPfxSingletonSigsSlot();
1575 }
1576 }
1577 }
1578
1579
1580 void LinguisticaMainWindow::findSingletonSigsSlot()
1581 {
1582 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1583
1584 if( m_lexicon->GetMiniCount() )
1585 {
1586 if( isCorrectAffix( STEM_FINAL ) )
1587 {
1588
1589 // Run successor freq function, log if desired
1590 if( m_logging ) OpenLogFile();
1591 current_mini->FindSingletonSignatures();
1592
1593 if( m_logging ) CloseLogFile();
1594
1595 // Update corpus words
1596 m_lexicon->DoWordUpdates();
1597
1598 // Unsaved work
1599 m_projectDirty = true;
1600
1601 // Update tree view
1602 emit updateAllViewsSignal();
1603 }
1604 else
1605 {
1606 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1607 new_mini->SetAffixLocation( STEM_FINAL );
1608 new_mini->AddToWordCollection(current_mini->GetWords(),
1609 CMiniLexicon::WW_All);
1610 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1611 findSingletonSigsSlot();
1612 }
1613 }
1614 }
1615
1616
1617 void LinguisticaMainWindow::pfxLooseFitSlot()
1618 {
1619 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1620
1621 if( m_lexicon->GetMiniCount() )
1622 {
1623 if( isCorrectAffix( STEM_INITIAL ) )
1624 {
1625
1626 // Run successor freq function, log if desired
1627 if( m_logging ) OpenLogFile();
1628 current_mini->LooseFit();
1629
1630 if( m_logging ) CloseLogFile();
1631
1632 // Update corpus words
1633 m_lexicon->DoWordUpdates();
1634
1635 // Unsaved work
1636 m_projectDirty = true;
1637
1638 // Update tree view
1639 emit updateAllViewsSignal();
1640 }
1641 else
1642 {
1643 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1644 new_mini->SetAffixLocation( STEM_INITIAL );
1645 new_mini->AddToWordCollection(current_mini->GetWords(),
1646 CMiniLexicon::WW_All);
1647 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1648 pfxLooseFitSlot();
1649 }
1650 }
1651 }
1652
1653
1654 void LinguisticaMainWindow::looseFitSlot()
1655 {
1656 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
1657
1658 if( m_lexicon->GetMiniCount() )
1659 {
1660 if( isCorrectAffix( STEM_FINAL ) )
1661 {
1662
1663 // Run successor freq function, log if desired
1664 if( m_logging ) OpenLogFile();
1665 current_mini->LooseFit();
1666
1667 if( m_logging ) CloseLogFile();
1668
1669 // Update corpus words
1670 m_lexicon->DoWordUpdates();
1671
1672 // Unsaved work
1673 m_projectDirty = true;
1674
1675 // Update tree view
1676 emit updateAllViewsSignal();
1677 }
1678 else
1679 {
1680 CMiniLexicon* new_mini = m_lexicon->GetMiniLexicon( m_lexicon->NewMiniLexicon() );
1681 new_mini->SetAffixLocation( STEM_FINAL );
1682 new_mini->AddToWordCollection(current_mini->GetWords(),
1683 CMiniLexicon::WW_All);
1684 m_lexicon->SetActiveMiniIndex( new_mini->GetIndex() );
1685 looseFitSlot();
1686 }
1687 }
1688 }
1689
1690 void LinguisticaMainWindow::showToolbarsSlot(bool b)
1691 {
1692 if (b) m_Toolbar->show();
1693 else m_Toolbar->hide();
1694 }
1695
1696
1697 void LinguisticaMainWindow::showStatusBarSlot(bool b)
1698 {
1699 if( b ) statusBar()->show();
1700 else statusBar()->hide();
1701 }
1702
1703
1704 void LinguisticaMainWindow::saveBrokenCorpusSlot()
1705 {
1706 QString BrokenCorpusFileName = m_corpusFileName.left( m_corpusFileName.find('.') ) + "_Broken.txt";
1707 BrokenCorpusFileName = Q3FileDialog::getSaveFileName( BrokenCorpusFileName,
1708 "Text Documents (*.txt)",
1709 this,
1710 "save file dialog"
1711 "Choose a folder to save under" );
1712
1713 if( BrokenCorpusFileName.length() == 0 ) return;
1714
1715 m_lexicon->MakeBrokenCorpus( BrokenCorpusFileName );
1716 }
1717
1718
1719 void LinguisticaMainWindow::helpAboutSlot()
1720 {
1721 HelpAboutDialog *helpDlg = new HelpAboutDialog( this );
1722 if( helpDlg->exec() == QDialog::Accepted )
1723 {
1724 // Do nothing
1725 }
1726 else
1727 {
1728 // Do nothing
1729 }
1730 delete helpDlg;
1731 }
1732
1733
1734 void LinguisticaMainWindow::newMiniLexiconActionSlot()
1735 {
1736 int index;
1737
1738 for( index = m_lexicon->GetMiniSize(); index >= 0; index-- )
1739 {
1740 if( m_lexicon->GetMiniLexicon(index) )
1741 {
1742 index++;
1743 break;
1744 }
1745 }
1746
1747 if( index == 0 )
1748 {
1749 newFileActionSlot();
1750 return;
1751 }
1752
1753 // Create the new mini
1754 index = m_lexicon->NewMiniLexicon();
1755 m_lexicon->SetActiveMiniIndex( index );
1756
1757 // Populate its words
1758 populateWordsActionSlot();
1759
1760
1761 QString mini_name( "Mini-Lexicon %1" );
1762 mini_name = mini_name.arg( index + 1 );
1763 QString remark = "Before analysis; words only";
1764 m_lexicon->GetDLHistory()->append( mini_name, remark, m_lexicon->GetMiniLexicon( index ) );
1765 }
1766
1767
1768 void LinguisticaMainWindow::deleteMiniLexiconActionSlot()
1769 {
1770 if( m_lexicon->GetMiniCount() == 1 )
1771 {
1772 clearLexiconSlot();
1773 }
1774 else
1775 {
1776 int active = m_lexicon->GetActiveMiniIndex();
1777 m_lexicon->DeleteMiniLexicon( active );
1778 }
1779
1780 SetDocType( NO_DOC );
1781 emit updateAllViewsSignal();
1782 }
1783
1784
1785 void LinguisticaMainWindow::autoLayeringActionSlot()
1786 {
1787 if( m_lexicon->GetMiniCount() )
1788 {
1789 // Run all suffix functions, log if desired
1790 if( m_logging ) OpenLogFile();
1791 m_lexicon->FindSuffixes( true );
1792
1793 if( m_logging ) CloseLogFile();
1794
1795 // Update corpus words
1796 m_lexicon->DoWordUpdates();
1797
1798 // Unsaved work
1799 m_projectDirty = true;
1800
1801 // Update tree view
1802 emit updateAllViewsSignal();
1803 }
1804 }
1805
1806
1807 void LinguisticaMainWindow::populateWordsActionSlot()
1808 {
1809 int index = m_lexicon->GetActiveMiniIndex();
1810 CMiniLexicon* active, * other;
1811
1812 QStringList notIncluded, included;
1813
1814 if( m_lexicon->GetMiniLexicon( index-1 ) )
1815 {
1816 included << "Mini-Lexicon " + QString("%1").arg( index ) + " : Unanalyzed Words";
1817 included << "Mini-Lexicon " + QString("%1").arg( index ) + " : Stems";
1818 notIncluded << "Mini-Lexicon " + QString("%1").arg( index ) + " : Analyzed Words";
1819 }
1820 for( int i=0; i < m_lexicon->GetMiniSize(); i++ )
1821 {
1822 if( i != index && i != index-1 && m_lexicon->GetMiniLexicon(i) )
1823 {
1824 notIncluded << "Mini-Lexicon " + QString("%1").arg( i+1 ) + " : Analyzed Words";
1825 notIncluded << "Mini-Lexicon " + QString("%1").arg( i+1 ) + " : Unanalyzed Words";
1826 notIncluded << "Mini-Lexicon " + QString("%1").arg( i+1 ) + " : Stems";
1827 }
1828 }
1829
1830 ListBuilderDialog *dlg = new ListBuilderDialog( "Linguistica : Populate Mini-Lexicon",
1831 notIncluded, included, this );
1832 if( dlg->exec() == QDialog::Accepted )
1833 {
1834 Q3ListBoxItem* included = dlg->GetIncluded()->item(0);
1835 QString item;
1836
1837 // Populate the word collection of a new mini
1838 active = m_lexicon->GetMiniLexicon( index );
1839
1840
1841 while( active && included )
1842 {
1843 item = included->text();
1844 index = item.find( " :" ) - 1;
1845 index = item.mid( index, 1 ).toInt() - 1;
1846
1847 other = m_lexicon->GetMiniLexicon( index );
1848 if( !other ) continue;
1849
1850 if( item.find( "Unanalyzed" ) >= 0 )
1851 {
1852 active->AddToWordCollection(
1853 other->GetWords(), CMiniLexicon::WW_UnanalyzedOnly);
1854 }
1855 else if( item.find( "Analyzed" ) >= 0 )
1856 {
1857 active->AddToWordCollection(other->GetWords(),
1858 CMiniLexicon::WW_AnalyzedOnly);
1859 }
1860 else if( item.find( "Stems" ) >= 0 )
1861 {
1862 active->AddToWordCollection( other->GetStems() );
1863 }
1864
1865 included = included->next();
1866 }
1867 }
1868 else
1869 {
1870 // Do nothing
1871 }
1872 delete dlg;
1873
1874 emit updateTreeViewSignal();
1875 }
1876
1877
1878 void LinguisticaMainWindow::addToBorrowedSigsSlot()
1879 {
1880 int index = m_lexicon->GetActiveMiniIndex();
1881 CMiniLexicon* active, * other;
1882
1883 QStringList notIncluded, included;
1884
1885 if( m_lexicon->GetMiniLexicon( index-1 ) )
1886 {
1887 included << "Mini-Lexicon " + QString("%1").arg( index ) + " : Signatures";
1888 }
1889 for( int i=0; i < m_lexicon->GetMiniSize(); i++ )
1890 {
1891 if( i != index-1 && m_lexicon->GetMiniLexicon(i) )
1892 {
1893 notIncluded << "Mini-Lexicon " + QString("%1").arg( i+1 ) + " : Signatures";
1894 }
1895 }
1896
1897 ListBuilderDialog *dlg = new ListBuilderDialog( "Linguistica : Populate Mini-Lexicon",
1898 notIncluded, included, this );
1899 if( dlg->exec() == QDialog::Accepted )
1900 {
1901 Q3ListBoxItem* included = dlg->GetIncluded()->item(0);
1902 QString item;
1903
1904 // Populate the word collection of a new mini
1905 active = m_lexicon->GetMiniLexicon( index );
1906
1907 while( active && included )
1908 {
1909 item = included->text();
1910 index = item.find( " :" ) - 1;
1911 index = item.mid( index, 1 ).toInt() - 1;
1912
1913 other = m_lexicon->GetMiniLexicon( index );
1914 if( !other ) continue;
1915
1916 included = included->next();
1917 }
1918 }
1919 else
1920 {
1921 // Do nothing
1922 }
1923 delete dlg;
1924
1925 emit updateTreeViewSignal();
1926 }
1927
1928
1929
1930
1931 void LinguisticaMainWindow::RunSedSlot()
1932 {
1933 QMessageBox::information( this, "Debug","Finding word neighbors","OK" );
1934 if ( m_lexicon)
1935 {
1936 if ( m_Words_InitialTemplates != NULL)
1937 {
1938 QMessageBox::information( this, "Attention","You have run the SED !","OK" );
1939 return;
1940 }
1941
1942 // StringEdit Distance Init
1943 m_Words_InitialTemplates = new CTemplateCollection;
1944 m_Words_Templates = new CTemplateCollection;
1945
1946 if( m_logging ) OpenLogFile();
1947
1948
1949 FindAllEditDistances(m_Words_InitialTemplates);
1950 FindAllWordNeighbors(m_lexicon);
1951
1952
1953 if (false) // John Goldsmith Dec 28 2008 testing what follows:
1954 {
1955 CheckForConflations(m_Words_Templates, m_Words_InitialTemplates);
1956
1957 // Update the Stickness
1958 m_Words_Templates ->UpdateGlobalStickNess2();
1959
1960 // Move Common Head/Tail
1961 m_Words_Templates ->AdjustTemplatesByMovingCommonTailOrHead2(0);
1962
1963 // Collapse algorithm 1
1964 m_Words_Templates ->CollapseAlgorithm1(1);
1965
1966 // Then sort these templates again.
1967 m_Words_Templates ->SetSwitchOfSortingValue(true);
1968 m_Words_Templates ->SetSortValidFlag(false);
1969 m_Words_Templates ->Sort(TEMPLATE_SORT);
1970
1971
1972 // Next, I tried the absorption algorithm
1973 m_Words_Templates ->AbsorbWords1(1);
1974 m_Words_Templates ->SetSwitchOfSortingValue(true);
1975 m_Words_Templates ->SetSortValidFlag(false);
1976 m_Words_Templates ->Sort(TEMPLATE_SORT);
1977
1978
1979 // Next, I tried the Paradigmatic graph function
1980 m_Words_Templates ->UpdateGlobalStickNess2();
1981 m_Words_Templates ->FindMorphemePrefixOrSuffixWithParadigmaticGraph(1);
1982
1983 // Then sort these templates again.
1984 m_Words_Templates ->SetSwitchOfSortingValue(true);
1985 m_Words_Templates ->SetSortValidFlag(false);
1986 m_Words_Templates ->Sort(TEMPLATE_SORT);
1987
1988
1989
1990
1991 m_Words_Templates ->OutputTemplatesForGoldStand();
1992 } // end of if (FALSE);
1993 emit updateTreeViewSignal();
1994 }
1995 else
1996 {
1997 QMessageBox::information( this, "Attention","Lexicon is NULL","OK" );
1998 }
1999 if( m_logging ) CloseLogFile();
2000 }
2001
2002
2003 void LinguisticaMainWindow::FindSlicesSlot()
2004 {
2005 if( m_lexicon && m_lexicon->GetMiniCount())
2006 {
2007 //QTime t; t.start();
2008
2009 if (m_logging) OpenLogFile();
2010
2011 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
2012 CWordCollection* Words = current_mini->GetWords();
2013
2014 SliceCollection MySlices;
2015 StringInventory MyStringInventory;
2016 setStatusBar1("Finding slices...");
2017 MyStringInventory.addwordcollection(Words, MySlices, status_display());
2018
2019 if (m_logging) { MySlices.writetolog(*GetLogFileStream()); }
2020
2021 MySlices.FindWordPairs(status_display(), m_lexicon);
2022
2023 if (m_logging) CloseLogFile();
2024
2025 //std::cout << "FindSlices:: Time elapsed: " << t.elapsed() << "ms." << std::endl;
2026 }
2027 }
2028
2029
2030 /////////////////////////////////////////////////////////////////
2031 void LinguisticaMainWindow::FindAllWordNeighbors(CLexicon* MyLexicon )
2032 {
2033
2034 MyLexicon->GetSEDWords()->FindAllWordNeighbors(MyLexicon);
2035 return;
2036
2037 }
2038
2039
2040
2041 /////////////////////////////////////////////////////////////////
2042 //// FindStringEditDistance
2043 void LinguisticaMainWindow::FindAllEditDistances(CTemplateCollection* pContainer)
2044 {
2045 pContainer->FindAllEditDistances ( m_lexicon, m_lexicon->GetSEDWords()) ;
2046 return;
2047 }
2048
2049
2050 void LinguisticaMainWindow::CheckForConflations(CTemplateCollection* Target, CTemplateCollection* Source)
2051 {
2052 Target ->CheckForConflations(Source);
2053 }
2054
2055 bool LinguisticaMainWindow::isCorrectAffix( eAffixLocation affixLoc )
2056 {
2057 CMiniLexicon* mini = m_lexicon->GetMiniLexicon( m_lexicon->GetActiveMiniIndex() );
2058 eAffixLocation current = mini->GetAffixLocation();
2059
2060 if( current == affixLoc ) return TRUE;
2061
2062 if( ( mini->GetSuffixes() && !mini->GetSuffixes()->GetCount() ) ||
2063 ( mini->GetPrefixes() && !mini->GetPrefixes()->GetCount() ) )
2064 {
2065 mini->SetAffixLocation( affixLoc );
2066 return TRUE;
2067 }
2068
2069 switch( affixLoc )
2070 {
2071 case STEM_INITIAL:
2072 case WORD_INITIAL:
2073 if( current == STEM_INITIAL || current == WORD_INITIAL ) return TRUE;
2074 else return FALSE;
2075
2076 case STEM_FINAL:
2077 case WORD_FINAL:
2078 default:
2079 if( current == STEM_FINAL || current == WORD_FINAL ) return TRUE;
2080 else return FALSE;
2081 }
2082 }
2083
2084 void LinguisticaMainWindow::commandLineCloseSlot()
2085 { close(); }
2086
2087 void LinguisticaMainWindow::executeCommandLineArgs(int count,
2088 bool mini, bool prefix, bool suffix)
2089 {
2090 if (m_corpusFileName.isEmpty()) {
2091 // XXX. no corpus file chosen! let user know.
2092 return;
2093 }
2094
2095 if( count != 0 ) SetNumberOfTokens( count );
2096
2097 m_lexicon->ClearAll();
2098
2099 // Log if desired.
2100 if( m_logging ) OpenLogFile();
2101
2102 // Read words into lexicon from the corpus
2103 Q_ASSERT(!m_corpusFileName.isEmpty());
2104 m_lexicon->ReadCorpus(m_corpusFileName, GetNumberOfTokens());
2105
2106 if( mini )
2107 {
2108 if( suffix ) m_lexicon->FindSuffixes( TRUE );
2109 if( prefix ) m_lexicon->FindPrefixes( TRUE );
2110
2111 }
2112 else
2113 {
2114 if( suffix ) m_lexicon->FindSuffixes();
2115 if( prefix ) m_lexicon->FindPrefixes();
2116
2117 }
2118
2119 if( m_logging ) CloseLogFile();
2120
2121 // Clear the collection view
2122 m_collectionView->clear();
2123 m_docType = NO_DOC;
2124
2125 int SlashLoc = m_corpusFileName.findRev('\\');
2126 if( SlashLoc < 0 ) SlashLoc = m_corpusFileName.findRev('/');
2127
2128 if( m_projectDirectory.length() == 0 ) m_projectDirectory = m_corpusFileName.left( SlashLoc + 1 );
2129 else if( m_projectDirectory.at( m_projectDirectory.length()-1 ) != '/' ) m_projectDirectory = m_projectDirectory + "/";
2130 if( m_projectDirectory.length() == 0 ) m_projectDirectory = "./";
2131
2132 m_projectName = m_corpusFileName.mid ( SlashLoc + 1 );
2133 int NameLoc = m_projectName.findRev(".");
2134 m_projectName = m_projectName.left( NameLoc );
2135 m_projectIndex = 0;
2136
2137 if( m_goldStdFileName.length() > 0 )
2138 {
2139 m_goldStdOutputFile = m_projectDirectory + m_projectName + "_GoldStandardComparison.txt";
2140 compareGoldStdSlot();
2141 }
2142
2143 saveFileActionSlot();
2144
2145 // Update tree view
2146 emit updateAllViewsSignal();
2147 }
2148
2149
2150 // YuHu Add for output morphological cut corpus for MT
2151 // TODO: Need change after 2005/11/30 Fix after Lexicon is done
2152 void LinguisticaMainWindow::editCorpusForMT()
2153 {
2154 /*
2155 QString line;
2156 QString FirstPiece, RemainingPiece;
2157 QString theWord;
2158 CStem* theCStem;
2159 CParse* theParse;
2160 StringToParse* TempSedCuts;
2161 StringToParse::Iterator StringToParseIt;
2162 StringToPtrCStem SFCuts;
2163 StringToPtrCStem SedCuts;
2164 StringToCStem::Iterator SFIt;
2165 StringToCStem* TempSFCut;
2166 int Strategy; // we discussed the strategy 1, 2, 3, 4
2167
2168
2169 // Get the Lingustica analyses result SF or PF
2170 if ( !m_lexicon) return;
2171 TempSFCut = m_lexicon ->GetWords();
2172
2173 for ( SFIt = TempSFCut ->begin(); SFIt != TempSFCut ->end(); SFIt++)
2174 {
2175 theWord = SFIt.key();
2176 theCStem = &SFIt.data();
2177 SFCuts.insert(theWord, theCStem);
2178 }
2179
2180 // Get SED analyses
2181 if ( m_Words_Templates != NULL)
2182 {
2183 TempSedCuts = m_Words_Templates ->GetParsedResult();
2184 for ( StringToParseIt = TempSedCuts ->begin(); StringToParseIt != TempSedCuts ->end(); StringToParseIt++)
2185 {
2186 theWord = StringToParseIt.key();
2187 theParse = StringToParseIt.data();
2188 theCStem = new CStem(*theParse);
2189 SedCuts.insert(theWord, theCStem);
2190 }
2191 }
2192
2193 // 3. Read MT Corpus File
2194
2195 QString MTFileName;
2196 QString FileNameStrippedDot;
2197 QString outputMTFileName_SF;
2198 QString outputMTFileName_SED;
2199
2200
2201 MTFileName = QFileDialog::getOpenFileName( m_projectDirectory,
2202 "Files (*.*)",
2203 this,
2204 "open file dialog",
2205 "Choose a file to open" );
2206
2207 if( !MTFileName.isEmpty() )
2208 {
2209
2210 }
2211 else
2212 {
2213 return;
2214 }
2215
2216 FileNameStrippedDot = MTFileName.left(MTFileName.find(QString(".")));
2217
2218
2219 for ( Strategy =1; Strategy <=4; Strategy++)
2220 {
2221 outputMTFileName_SF = FileNameStrippedDot + "_Output_SF_" + QString("%1").arg(Strategy) + ".txt";
2222 m_lexicon ->CutMtCorpusWithMorphologyAnalyses(MTFileName, outputMTFileName_SF,SFCuts,Strategy);
2223 }
2224
2225 if ( m_Words_Templates != NULL)
2226 {
2227 for ( Strategy =1; Strategy <=4; Strategy++)
2228 {
2229 outputMTFileName_SED = FileNameStrippedDot + "_Output_SED_" + QString("%1").arg(Strategy) + ".txt";
2230 m_Words_Templates ->CutMtCorpusWithMorphologyAnalyses(MTFileName, outputMTFileName_SED,SedCuts,Strategy);
2231 }
2232
2233
2234 }
2235 */
2236 }
2237
2238 //////////////////////////////////////////////////////////////////////////////
2239 // Test
2240 //////////////////////////////////////////////////////////////////////////////
2241
2242 void LinguisticaMainWindow::testMultiDimensionDisplaySlot()
2243 {
2244 int NumberOfSymbols;
2245 int NumberOfStates;
2246 double** ptrData;
2247 IntToString listOfSymbols;
2248 int i,j;
2249 int NumberOfIterations =100;
2250
2251 NumberOfSymbols = 4;
2252 NumberOfStates = 4;
2253
2254 // Update the GraphicView to Display the HMM multidimension data
2255 ptrData = new double*[NumberOfSymbols];
2256 for ( i=0; i<NumberOfSymbols; i++)
2257 {
2258 ptrData[i] = new double[NumberOfStates] ;
2259 }
2260
2261 // assign initial ptrData
2262 for(i=0; i<NumberOfSymbols;i++)
2263 {
2264 listOfSymbols.insert(i, QString("s%1").arg(i));
2265 for(j=0; j<NumberOfStates; j++)
2266 {
2267 ptrData[i][j] = 1.0 / NumberOfStates;
2268 }
2269 }
2270
2271 // Iterations...
2272 for (i=0; i<NumberOfIterations; i++)
2273 {
2274
2275 // Display on Graphic View
2276 updateSmallGraphicDisplaySlotForMultiDimensionData(NumberOfStates,
2277 NumberOfSymbols,
2278 ptrData,
2279 listOfSymbols);
2280
2281
2282 //Alter the ptrData
2283 for(j=0; j<NumberOfSymbols;j++)
2284 {
2285 ptrData[j][j % NumberOfStates] += 0.1 / NumberOfStates;
2286
2287 }
2288
2289 // Sleep for a short time : Is there any Qt sleep function ?
2290 int dummy=0;
2291 for(j=0; j<500000; j++)
2292 {
2293 dummy++;
2294 dummy--;
2295 }
2296
2297 }
2298 //clean ptrData
2299 for(i=0; i<NumberOfSymbols; i++)
2300 {
2301 delete [] ptrData[i];
2302 }
2303
2304 delete []ptrData;
2305
2306 }
2307
2308 void LinguisticaMainWindow::goldwaterMethodSlot()
2309 {
2310 QMessageBox::information ( this, "GoldwaterMethod", "Begin Goldwater Thesis Morphology Learning Algorithm!" );
2311 }
2312
2313 void LinguisticaMainWindow::suffixesCollapse_two_signaturesAction_activated()
2314 {
2315 int i;
2316 i =2;
2317 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
2318 CSignatureCollection TheseSignatures (current_mini);
2319
2320
2321 int NumberOfSignaturesSelected = 0;
2322 //unused variable:
2323 // QListViewItem* selectedItem = NULL;
2324
2325 m_collectionView->setSelectionMode (Q3ListView::Extended);
2326
2327 Q3ListViewItemIterator it( m_collectionView );
2328
2329 while ( it.current() )
2330 {
2331 if (it.current()->isSelected() )
2332 {
2333 NumberOfSignaturesSelected++;
2334 CSignatureListViewItem *item = (CSignatureListViewItem*) it.current();
2335 TheseSignatures << item->GetSignature();
2336 }
2337 ++it;
2338 }
2339
2340 if (NumberOfSignaturesSelected != 2)
2341 {
2342 QMessageBox::warning( m_lexicon->GetDocument(),
2343 "Linguistica",
2344 "Select exactly two signatures, and press command again",
2345 QMessageBox::Ok,
2346 QMessageBox::NoButton,
2347 QMessageBox::NoButton );
2348
2349 return;
2350 }
2351
2352
2353
2354
2355
2356
2357 m_collectionView->setSelectionMode (Q3ListView::Single);
2358 }
2359 void LinguisticaMainWindow::toggleMultipleSelectionSlot()
2360 {
2361 if (m_collectionView->selectionMode() == Q3ListView::Single )
2362 {
2363 m_collectionView->setSelectionMode(Q3ListView::Extended);
2364 } else
2365 {
2366 m_collectionView->setSelectionMode (Q3ListView::Single);
2367
2368 }
2369 }
2370
2371
2372 void LinguisticaMainWindow::addContentToCommandLine(QString content)
2373 {
2374 m_commandLine->insert(content);
2375 }
2376
2377 /** \page page1 The GUI: An overview
2378
2379 \section sec The main screen
2380 This page contains the subsections \ref subsection1 and \ref subsection2.
2381 For more info see page \ref page2. Hello??
2382 \subsection subsection1 The first subsection
2383 Text. Lxa
2384 \subsection subsection2 The second subsection
2385 More text.
2386
2387 ! \page page2 How strings are represented: The CParse class
2388 Even more info.
2389 ! \page page3 Collection classes
2390 ! \page page4 The Lexicon class
2391 ! \page page5 A MiniLexicon: Signatures, Stems, Affixes
2392 */
2393
2394
2395
2396 void LinguisticaMainWindow::fsaTestFuncAction()
2397 {
2398 if( m_lexicon && m_lexicon->GetMiniCount())
2399 {
2400 CMiniLexicon* current_mini = m_lexicon->GetMiniLexicon(m_lexicon->GetActiveMiniIndex());
2401 if(current_mini->GetFSA())
2402 {
2403 current_mini->GetFSA()->ResetDisplay();
2404 current_mini->GetFSA()->FSATestFunc();
2405 current_mini->GetFSA()->FSAListDisplay(m_collectionView,m_lexicon->GetOutFilter(),false);
2406 }
2407 }
2408 }
2409
automatic morphological analysis of a text