StemListViewItem.cpp

   1 // Implementation of CWordListViewItem, CStemListViewItem methods
   2 // Copyright © 2009 The University of Chicago
   3 #include "StemListViewItem.h"
   4
   5 #include <Q3ListViewItem>
   6 #include <Q3ListView>
   7 #include <QString>
   8 #include "Signature.h"
   9 #include "Stem.h"
  10 #include "CompareFunc.h"
  11
  12 namespace {
  13 typedef QMap<QString, QString> StringToString;
  14 }
  15 //-------------------------------------------------------------------------------------------//
  16 CStemListViewItem::CStemListViewItem( Q3ListView *parent,
  17                     QString stem,
  18                     int mini,
  19                     CStem* pStem,
  20                     StringToString* filter,
  21                                         int char_count )
  22 : Q3ListViewItem( parent, stem )
  23 {
  24   m_Stem = pStem;
  25   m_filter = filter;
  26   m_char_count = char_count;
  27   m_mini = mini;
  28 }
  29 //-------------------------------------------------------------------------------------------//
  30 CStemListViewItem::CStemListViewItem( Q3ListViewItem *parent,
  31                     QString stem,
  32                     int mini,
  33                     CStem* pStem,
  34                     StringToString* filter,
  35                                         int char_count )
  36 : Q3ListViewItem( parent, stem )
  37 {
  38   m_Stem = pStem;
  39   m_filter = filter;
  40   m_char_count = char_count;
  41   m_mini = mini;
  42 }
  43 //-------------------------------------------------------------------------------------------//
  44 int CStemListViewItem::compare(Q3ListViewItem* pOther, int col, bool asc) const
  45 //-------------------------------------------------------------------------------------------//
  46 {
  47         CStemListViewItem* other = static_cast<CStemListViewItem*>(pOther);
  48
  49                 switch( col )
  50                 {
  51                 case 1:
  52                   if( m_Stem ) return MakeComparable (m_Stem->GetPhonologicalInformationContent(), other->m_Stem->GetPhonologicalInformationContent());
  53                 case 2:
  54                   if( m_Stem ) return MakeComparable (m_Stem->GetLengthOfPointerToMe(), other->GetStem()->GetLengthOfPointerToMe());
  55                 case 3:
  56                   if( m_Stem ) return MakeComparable (m_Stem->GetCorpusCount(), other->GetStem()->GetCorpusCount());
  57                 case 8:
  58                   if( m_Stem ) return MakeComparable (m_Stem->GetUnigramLogProb(), other->GetStem()->GetUnigramLogProb());
  59                 default:
  60                   return Q3ListViewItem::compare(pOther, col, asc);
  61                 }
  62
  63 }
  64 //-------------------------------------------------------------------------------------------//
  65 QString CStemListViewItem::key( int column, bool ascending ) const
  66 //-------------------------------------------------------------------------------------------//
  67 {
  68   CSignature* sigs;
  69   int count;
  70
  71   switch( column )
  72   {
  73
  74   case 3:
  75     if( m_Stem )
  76     {
  77       return QString("%1").arg( m_Stem->GetCorpusCount(), 10 );
  78     }
  79     else
  80     {
  81       count = 0;
  82
  83                 for (CStemListViewItem* child =
  84                                         static_cast<CStemListViewItem*>(
  85                                         firstChild());
  86                                 child != 0;
  87                                 child = static_cast<CStemListViewItem*>(
  88                                         child->nextSibling()))
  89                         if (CStem* stem = child->GetStem())
  90                                 count += stem->GetCorpusCount();
  91
  92       return QString("%1").arg( count, 10 );
  93     }
  94
  95   case 4:
  96     if( m_Stem )
  97     {
  98        sigs = m_Stem->GetSuffixSignature();
  99        if( sigs )
 100         {
 101             return sigs->Display('.', m_filter);
 102         }
 103       else return "";
 104     }
 105     else return "";
 106   case 5:
 107     if( m_Stem )
 108     {
 109       sigs = m_Stem->GetPrefixSignature();
 110       if( sigs ) return sigs->Display('.', m_filter);
 111       else return "";
 112     }
 113     else return "";
 114   case 6:
 115     if( m_Stem ) return m_Stem->GetConfidence();
 116     else return "";
 117   case 7:
 118     if( m_Stem ) return m_Stem->DisplayStemType();
 119     else return "";
 120    case 9:
 121         return m_Stem->GetTier1()->Display();
 122   case 10:
 123         return m_Stem->GetTier1_Skeleton()->Display();
 124   case 11:
 125         return m_Stem->GetTier2()->Display();
 126
 127
 128   default:
 129     return Q3ListViewItem::key( column, ascending );
 130   }
 131 }
 132 //-------------------------------------------------------------------------------------------//
 133 QString CStemListViewItem::text( int column ) const
 134 //-------------------------------------------------------------------------------------------//
 135 {
 136 //  CParse*    pfxs;
 137     CSignature* sigs;
 138     QString     dummy;
 139   int count;
 140
 141   switch( column )
 142   {
 143
 144   case 1:
 145     if( m_Stem ) return dummy.setNum( m_Stem->ComputeDL( m_char_count ) );
 146     else return "";
 147
 148   case 2:
 149     if( m_Stem ) return dummy.setNum(  m_Stem->GetLengthOfPointerToMe( ) );
 150     else return "";
 151
 152
 153   case 3:
 154     if( m_Stem )
 155     {
 156       return QString("%1").arg( m_Stem->GetCorpusCount() );
 157     }
 158     else
 159     {
 160       count = 0;
 161
 162                 for (CStemListViewItem* child =
 163                                         static_cast<CStemListViewItem*>(
 164                                         firstChild());
 165                                 child != 0;
 166                                 child = static_cast<CStemListViewItem*>(
 167                                         child->nextSibling()))
 168                         if (CStem* stem = child->GetStem())
 169                                 count += stem->GetCorpusCount();
 170
 171       return QString("%1").arg( count );
 172     }
 173
 174
 175
 176   case 4:
 177
 178     if( m_Stem )
 179     {
 180         sigs = m_Stem->GetSuffixSignature();
 181         if( sigs )
 182         {
 183           return sigs->Display('.', m_filter);
 184         }
 185       else return "";
 186     }
 187     else return "";
 188
 189   case 5:
 190     if( m_Stem )
 191     {
 192       sigs = m_Stem->GetPrefixSignature();
 193       if( sigs ) return sigs->Display('.', m_filter);
 194       else return "";
 195     }
 196     else return "";
 197   case 6:
 198     if( m_Stem ) return m_Stem->GetConfidence();
 199     else return "";
 200   case 7:
 201     if( m_Stem ) return m_Stem->DisplayStemType();
 202     else return "";
 203   case 8:
 204         return QString("%1").arg ( m_Stem->GetUnigramLogProb() );
 205   case 9:
 206         return m_Stem->GetTier1()->Display();
 207   case 10:
 208         return m_Stem->GetTier1_Skeleton()->Display();
 209   case 11:
 210         return m_Stem->GetTier2()->Display();
 211   case 12:
 212     return QString("just placeholdin'");
 213           //return m_Stem->GetPhonologicalInformationContent();
 214
 215  default:
 216     return Q3ListViewItem::text( column );
 217   }
 218 }
 219 //-------------------------------------------------------------------------------------------//
 220 CWordListViewItem::CWordListViewItem (Q3ListView *parent,
 221         QString word, int mini, CStem* pWord,
 222         QMap<QString, QString>* filter,
 223         enum display_mode DisplayMode, int char_count)
 224 : Q3ListViewItem( parent, word )
 225 //-------------------------------------------------------------------------------------------//
 226 {
 227         m_pWord = pWord;
 228         m_filter = filter;
 229         m_DisplayMode = DisplayMode;
 230         m_char_count = char_count;
 231         m_mini = mini;
 232
 233         if ( m_pWord )
 234         {
 235                 m_DL = m_pWord->ComputeDL( m_char_count );
 236                 m_prefix = m_pWord->GetPiece( m_pWord->GetPrefixLoc() )
 237                                                  .Display( m_filter );
 238                 m_stem = m_pWord->GetStem().Display( m_filter );
 239                 m_suffix = m_pWord->GetPiece( m_pWord->GetSuffixLoc() )
 240                                                 .Display( m_filter );
 241                 m_pSig = m_pWord->GetSuffixSignature();
 242
 243                 if ( m_pSig == NULL )
 244                         m_pSig = m_pWord->GetPrefixSignature();
 245
 246                 if ( m_pSig != NULL )
 247                         m_pSig = m_pWord->GetSuffixSignature();
 248
 249                 if (m_pSig)     { m_signature = m_pSig->Display( '.', m_filter ); }
 250     //            else            { m_signature = ""; }
 251
 252 //              m_tier1 = m_pWord->GetTier1()->Display( ' ' );
 253 //              m_tier1_skeleton = m_pWord->GetTier1_Skeleton()->Display();
 254 //              m_tier2 = m_pWord->GetTier2()->Display();
 255         }
 256         else
 257         {
 258                 m_DL        = 0.0;
 259                 m_prefix    = "";
 260                 m_stem      = "";
 261                 m_suffix    = "";
 262                 m_pSig      = NULL;
 263                 m_signature = "";
 264                 m_tier1     = "";
 265                 m_tier1_skeleton = "";
 266                 m_tier2     = "";
 267         }
 268
 269
 270 }
 271
 272
 273 //-------------------------------------------------------------------------------------------//
 274 CWordListViewItem::CWordListViewItem(Q3ListViewItem *parent,
 275         QString word, int mini, CStem* pWord,
 276         QMap<QString, QString>* filter, enum display_mode DisplayMode,
 277         int char_count)
 278 : Q3ListViewItem( parent, word )
 279 //-------------------------------------------------------------------------------------------//
 280 {
 281         m_pWord = pWord;
 282         m_filter = filter;
 283         m_DisplayMode = DisplayMode;
 284         m_char_count = char_count;
 285         m_mini = mini;
 286         if( m_pWord )
 287         {
 288                 m_DL            = m_pWord->ComputeDL( m_char_count );
 289                 m_prefix        = m_pWord->GetPiece( m_pWord->GetPrefixLoc() ).Display( m_filter );
 290                 m_stem          = m_pWord->GetStem().Display(m_filter);
 291                 m_suffix        = m_pWord->GetPiece( m_pWord->GetSuffixLoc() ).Display( m_filter );
 292                 m_pSig          = m_pWord->GetSuffixSignature();
 293
 294                 if( m_pSig == NULL ) m_pSig = m_pWord->GetPrefixSignature();
 295                 if( m_pSig != NULL ) m_signature = m_pSig->Display( '.', m_filter );
 296                 else m_signature = "";
 297
 298                 m_tier1         = m_pWord->GetTier1()->Display();
 299                 m_tier1_skeleton = m_pWord->GetTier1_Skeleton()->Display();
 300                 m_tier2         = m_pWord->GetTier2()->Display();
 301         }
 302         else
 303         {
 304                 m_DL            = 0.0;
 305                 m_prefix        = "";
 306                 m_stem          = "";
 307                 m_suffix        = "";
 308                 m_pSig          = NULL;
 309                 m_signature     = "";
 310                 m_tier1         = "";
 311                 m_tier1_skeleton= "";
 312                 m_tier2         = "";
 313         }
 314
 315 }
 316 //-------------------------------------------------------------------------------------------//
 317 int CWordListViewItem::compare(Q3ListViewItem* pOther, int col, bool asc) const
 318 //-------------------------------------------------------------------------------------------//
 319 {
 320         if (m_pWord == 0)
 321                 return Q3ListViewItem::compare(pOther, col, asc);
 322         CWordListViewItem& other = *static_cast<CWordListViewItem*>(pOther);
 323         CStem* other_word = other.m_pWord;
 324
 325         if (m_DisplayMode == MiniLexicon_MorphologyStuffFirst) {
 326                 switch (col) {
 327                 case 2:
 328                         return MakeComparable(m_DL, other.m_DL);
 329                 case 3:
 330                         return MakeComparable(m_pWord->GetCorpusCount(),
 331                                 other_word->GetCorpusCount());
 332                 case 10:
 333                         return MakeComparable(m_pWord->GetUnigramLogProb(),
 334                                 other_word->GetUnigramLogProb());
 335                 case 11:
 336                         return MakeComparable(m_pWord->GetUnigramComplexity(),
 337                                 other_word->GetUnigramComplexity());
 338                 case 12:
 339                         return MakeComparable(m_pWord->GetBigramLogProb(),
 340                                 other_word->GetBigramLogProb());
 341                 case 13:
 342                         return MakeComparable(m_pWord->GetBigramComplexity(),
 343                                 other_word->GetBigramComplexity());
 344                 default:
 345                         return Q3ListViewItem::compare(pOther, col, asc);
 346                 }
 347         }
 348
 349         // Phonology Stuff First
 350         switch (col) {
 351         case 1:
 352                 return MakeComparable(m_pWord->GetUnigramLogProb(),
 353                         other_word->GetUnigramLogProb());
 354         case 2:
 355                 return MakeComparable(m_pWord->GetUnigramComplexity(),
 356                         other_word->GetUnigramComplexity());
 357         case 3:
 358                 return MakeComparable(m_pWord->GetBigramLogProb(),
 359                         other_word->GetBigramLogProb());
 360         case 4:
 361                 return MakeComparable(m_pWord->GetBigramComplexity(),
 362                         other_word->GetBigramComplexity());
 363         case 5:
 364                 return MakeComparable(m_pWord->GetHMM_LogProbability(),
 365                         other_word->GetHMM_LogProbability());
 366         case 9:
 367                  return MakeComparable(m_mini, other.m_mini);
 368         case 10:
 369                  return MakeComparable(m_DL, other.m_DL);
 370         case 11:
 371                  return MakeComparable(m_pWord->GetCorpusCount(),
 372                         other_word->GetCorpusCount());
 373         default:
 374                 return Q3ListViewItem::compare(pOther, col, asc);
 375         }
 376 }
 377 //-------------------------------------------------------------------------------------------//
 378 QString CWordListViewItem::key( int column, bool ascending ) const
 379 //-------------------------------------------------------------------------------------------//
 380 {
 381     // fo
 382
 383   if( m_pWord )
 384   {
 385         if ( m_DisplayMode == MiniLexicon_MorphologyStuffFirst )
 386         {
 387                 switch( column )
 388                 {
 389                 case 1:
 390                         return QString( "%1" ).arg( 100 * m_mini, 10 );
 391
 392                 case 4:
 393                   return m_pWord->DisplayStemType();
 394                 case 5:
 395                   return m_signature;
 396                 case 6:
 397                   if( m_pSig && m_pWord->GetConfidence() == "" )
 398                   {
 399                         return m_pSig->GetRemark();
 400                   }
 401                   else
 402                   {
 403                         return m_pWord->GetConfidence();
 404                   }
 405                 case 7:
 406                   return m_suffix;
 407                 case 8:
 408                   return m_stem;
 409                 case 9:
 410                   return m_prefix;
 411
 412                 default:
 413                   return Q3ListViewItem::key( column, ascending );
 414                 }
 415         }// end of switch for MorphologyStuffFirst --
 416         else // Phonology Stuff First
 417         {
 418                 switch (column) {
 419                 case 1:
 420                         return QString("%1").arg(static_cast<int>(
 421                                 double(10000) * m_pWord->GetUnigramLogProb()),
 422                                 10);
 423                 case 2:
 424                         return QString("%1").arg(static_cast<int>(
 425                                 double(10000) * m_pWord->GetUnigramComplexity()),
 426                                 10);
 427                 case 3:
 428                         return QString("%1").arg(static_cast<int>(
 429                                 double(10000) * m_pWord->GetBigramLogProb()),
 430                                 10);
 431                 case 4:
 432                         return QString("%1").arg(static_cast<int>(
 433                                 double(10000) * m_pWord->GetBigramComplexity()),
 434                                 10);
 435                 case 5:
 436                         return QString("%1").arg(static_cast<int>(
 437                                 double(10000) * m_pWord->GetHMM_LogProbability()),
 438                                 10);
 439                 case 6:
 440                         return m_tier1;
 441                 case 7:
 442                         return m_tier1_skeleton;
 443                 case 8:
 444                         return m_tier2;
 445                 case 9:
 446                         return QString("%1").arg( 100 * m_mini, 10 );
 447                 case 10:
 448                         if (m_pWord == 0)
 449                                 return QString();
 450                         return QString("%1").arg(static_cast<int>(
 451                                 double(1000) * m_DL), 10);
 452                 case 11:
 453                         return QString("%1").arg(m_pWord->GetCorpusCount(), 10);
 454                 case 12:
 455                   return m_pWord->DisplayStemType();
 456                 case 13:
 457                   return m_signature;
 458                 case 14:
 459                   if( m_pSig && m_pWord->GetConfidence() == "")
 460                   {
 461                         return m_pSig->GetRemark();
 462                   }
 463                   else
 464                   {
 465                         return m_pWord->GetConfidence();
 466                   }
 467                 case 15:
 468                   return m_prefix;
 469                 case 16:
 470                   return m_stem;
 471                 case 17:
 472                   return m_suffix;
 473
 474
 475                 default:
 476                   return Q3ListViewItem::key( column, ascending );
 477                 }
 478         }
 479
 480   }
 481   else return Q3ListViewItem::key( column, ascending );
 482 }
 483 //-------------------------------------------------------------------------------------------//
 484 QString CWordListViewItem::text( int column ) const
 485 //-------------------------------------------------------------------------------------------//
 486 {
 487
 488
 489   if(! m_pWord) return QString("");
 490
 491    switch (m_DisplayMode)
 492    {
 493        case MiniLexicon_MorphologyStuffFirst:
 494        case Lexicon_Word:
 495           {
 496                     switch( column )
 497                     {
 498                             case 1:
 499                               return QString( "%1" ).arg( m_mini );
 500                             case 2:
 501                               return QString("%1").arg( m_DL );
 502                             case 3:
 503                               return QString("%1").arg( m_pWord->GetCorpusCount() );
 504                             case 4:
 505                               return m_pWord->DisplayStemType();
 506                             case 5:
 507                               return m_signature;
 508                             case 6:
 509                               if( m_pSig && m_pWord->GetConfidence() == "")
 510                               {
 511                                     return m_pSig->GetRemark();
 512                               }
 513                               else
 514                               {
 515                                     return m_pWord->GetConfidence();
 516                               }
 517                             case 7:
 518                               return m_prefix;
 519                             case 8:
 520                               return m_stem;
 521                             case 9:
 522                               return m_suffix;
 523                             case 10:
 524                                      return QString("%1").arg( m_pWord->GetUnigramLogProb() );
 525                             case 11:
 526                                     return QString("%1").arg( m_pWord->GetUnigramComplexity() );
 527                             case 12:
 528                                      return QString("%1").arg( m_pWord->GetBigramLogProb() );
 529
 530                             case 13:
 531                                     return QString("%1").arg( m_pWord->GetBigramComplexity() );
 532
 533                             case 14:
 534                                     return m_tier1;
 535                             case 15:
 536                                     return m_tier1_skeleton;
 537                             case 16:
 538                                     return m_tier2;
 539
 540
 541                             default:
 542                               return Q3ListViewItem::text( column );
 543                     }
 544                 break;
 545         };
 546         case MiniLexicon_PhonologyStuffFirst:
 547             {
 548                   switch( column )
 549                             {
 550                             case 1:
 551                                      return QString("%1").arg( m_pWord->GetUnigramLogProb() );
 552                             case 2:
 553                                     return QString("%1").arg( m_pWord->GetUnigramComplexity() );
 554                             case 3:
 555                                      return QString("%1").arg( m_pWord->GetBigramLogProb() );
 556                             case 4:
 557                                     return QString("%1").arg( m_pWord->GetBigramComplexity() );
 558                             case 5:
 559                                     return QString("%1").arg( m_pWord->GetHMM_LogProbability() );
 560                             case 6:
 561                                     return m_tier1;
 562                             case 7:
 563                                     return m_tier1_skeleton;
 564                             case 8:
 565                                     return m_tier2;
 566                             case 9:
 567                                     return QString( "%1" ).arg( m_mini );
 568                             case 10:
 569                               if( m_pWord ) return QString("%1").arg( m_DL );
 570                               else return "";
 571                             case 11:
 572                               return QString("%1").arg( m_pWord->GetCorpusCount() );
 573                             case 12:
 574                               return m_pWord->DisplayStemType();
 575                             case 13:
 576                               return m_signature;
 577                             case 14:
 578                               if( m_pSig && m_pWord->GetConfidence() == "")
 579                               {
 580                                     return m_pSig->GetRemark();
 581                               }
 582                               else
 583                               {
 584                                     return m_pWord->GetConfidence();
 585                               }
 586                             case 15:
 587                               return m_prefix;
 588                             case 16:
 589                               return m_stem;
 590                             case 17:
 591                               return m_suffix;
 592
 593                             default:
 594                               return Q3ListViewItem::text( column );
 595
 596                     }// end of switch on column...
 597             }// end of MiniLexicon_Phonology stuff first
 598       } //end of DisplayMode switch
 599
 600       return Q3ListViewItem::text( column );
 601 }