← Back to branch summary

~ubuntu-branches/ubuntu/feisty/ncbi-tools6/feisty

« back to all changes in this revision

Viewing changes to sequin/sequin7.c

  • Committer: Bazaar Package Importer
  • Author(s): Barry deFreese
  • Date: 2006-07-19 23:28:07 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20060719232807-et3cdmcjgmnyleyx
Tags: 6.1.20060507-3ubuntu1
Re-merge with Debian

Show diffs side-by-side

added added

removed removed

Lines of Context:
sequin/sequin7.c
29
29
*
30
30
* Version Creation Date:   1/3/98
31
31
*
32
 
* $Revision: 6.231 $
 
32
* $Revision: 6.246 $
33
33
*
34
34
* File Description: 
35
35
*
73
73
#include <alignmgr2.h>
74
74
#include <actutils.h>
75
75
#include <tax3api.h>
 
76
#include <algo/blast/api/blast_options_api.h>
 
77
#include <algo/blast/api/blast_seqalign.h>
 
78
#include <algo/blast/api/blast_api.h>
 
79
 
76
80
 
77
81
#define CONVERT_TO_JOIN  1
78
82
#define CONVERT_TO_ORDER 2
636
640
  if (ANS_NO == Message (MSG_YN, "Do you want to add an organism name and comment before saving the template?"))
637
641
  {
638
642
    bssp = BioseqSetNew ();
639
 
    bssp->_class = BioseqseqSet_class_empty_set;
 
643
    bssp->_class = BioseqseqSet_class_not_set;
640
644
    sep = SeqEntryNew ();
641
645
    sep->choice = 2;
642
646
    sep->data.ptrvalue = bssp;
692
696
      sep = SeqEntryNew ();
693
697
      sep->choice = 2;
694
698
      sep->data.ptrvalue = bssp;
695
 
      bssp->_class = BioseqseqSet_class_empty_set;
 
699
      bssp->_class = BioseqseqSet_class_not_set;
696
700
    
697
701
      org_name = DialogToPointer (org_dlg);
698
702
      if (!StringHasNoText (org_name))
761
765
  bfp = (BaseFormPtr) GetObjectExtra (w);
762
766
  if (bfp != NULL) {
763
767
    m = PulldownMenu (w, "File");
764
 
    FormCommandItem (m, "Export Template", bfp, VIB_MSG_EXPORT);
 
768
    FormCommandItem (m, "Export Template...", bfp, VIB_MSG_EXPORT);
765
769
  }
766
770
#endif
767
771
}
768
772
 
 
773
static void InitFormatFormActivate (WindoW w)
 
774
 
 
775
{
 
776
  IteM           exportItm;
 
777
  FormatFormPtr  ffp;
 
778
 
 
779
  ffp = (FormatFormPtr) GetObjectExtra (w);
 
780
  if (ffp != NULL) {
 
781
    if (ffp->activate != NULL) {
 
782
      ffp->activate (w);
 
783
    }
 
784
    exportItm = FindFormMenuItem ((BaseFormPtr) ffp, VIB_MSG_EXPORT);
 
785
    SafeSetTitle (exportItm, "Export Template...");
 
786
    SafeEnable (exportItm);
 
787
  }
 
788
}
 
789
 
769
790
extern ForM CreateFormatForm (Int2 left, Int2 top, CharPtr title,
770
791
                              BtnActnProc goToNext,
771
792
                              BtnActnProc goBack,
859
880
 
860
881
    RealizeWindow (w);
861
882
 
862
 
    if (activateForm != NULL) {
863
 
      SetActivate (w, activateForm);
864
 
    }
 
883
    ffp->activate = activateForm;
 
884
    SetActivate (w, InitFormatFormActivate);
865
885
  }
866
886
  return (ForM) w;
867
887
}
3894
3914
    if (replace) {
3895
3915
      changeme = JustSaveStringFromText (ffp->replaceTxt);
3896
3916
      FindReplaceInEntity (ffp->input_entityID, findme, changeme, caseCounts, wholeWord, replaceAll,
3897
 
                           FALSE, UPDATE_ONCE, NULL, NULL, NULL, doSeqIdLocal);
 
3917
                           FALSE, UPDATE_ONCE, NULL, NULL, NULL, doSeqIdLocal, NULL, NULL);
3898
3918
      GetRidOfEmptyFeatsDescStrings (ffp->input_entityID, NULL);
3899
3919
      ObjMgrSetDirtyFlag (ffp->input_entityID, TRUE);
3900
3920
      ObjMgrSendMsg (OM_MSG_UPDATE, ffp->input_entityID, 0, 0);
3901
3921
      MemFree (changeme);
3902
3922
    } else {
3903
3923
      FindReplaceInEntity (ffp->input_entityID, findme, NULL, caseCounts, wholeWord, FALSE,
3904
 
                           TRUE, UPDATE_ONCE, NULL, NULL, NULL, doSeqIdLocal);
 
3924
                           TRUE, UPDATE_ONCE, NULL, NULL, NULL, doSeqIdLocal, NULL, NULL);
3905
3925
    }
3906
3926
    MemFree (findme);
3907
3927
    Update ();
5240
5260
    /*
5241
5261
    StripTitleFromProtsInNucProts (sep);
5242
5262
    */
 
5263
    MoveFeatsFromPartsSet (sep);
5243
5264
    move_cds (sep); /* move CDS features to nuc-prot set */
5244
5265
  }
5245
5266
  /* ExtendGeneFeatIfOnMRNA (0, sep); */ /* gene on mRNA is full length */
5846
5867
      prevsalp = (Pointer PNTR) &(sap->data);
5847
5868
      while (salp != NULL) {
5848
5869
        nextsalp = salp->next;
5849
 
        if (salp->type <= 255) {
5850
 
          *(prevsalp) = salp->next;
5851
 
          salp->next = NULL;
5852
 
          SeqAlignFree (salp);
5853
 
        } else {
5854
 
          prevsalp = (Pointer PNTR) &(salp->next);
5855
 
        }
 
5870
        *(prevsalp) = salp->next;
 
5871
        salp->next = NULL;
 
5872
        SeqAlignFree (salp);
5856
5873
        salp = nextsalp;
5857
5874
      }
5858
5875
    }
7415
7432
  return osd.found;
7416
7433
}
7417
7434
 
7418
 
typedef struct stringconstraintform 
 
7435
 
 
7436
extern Boolean DoBioseqFeaturesMatchSequenceConstraint (BioseqPtr bsp, ValNodePtr feat_list, StringConstraintPtr scp)
 
7437
{
 
7438
  AsnExpOptPtr            aeop;
 
7439
  AsnIoPtr                aip;
 
7440
  ObjStringData           osd;
 
7441
  SeqFeatPtr              sfp;
 
7442
  ObjMgrPtr               omp;
 
7443
  ObjMgrTypePtr           omtp;
 
7444
  SeqMgrFeatContext       fcontext;
 
7445
  ValNodePtr              vnp;
 
7446
  
 
7447
  if (bsp == NULL) return FALSE;
 
7448
  if (scp == NULL) return TRUE; 
 
7449
  omp = ObjMgrGet ();
 
7450
  if (omp == NULL) return;
 
7451
  omtp = ObjMgrTypeFind (omp, OBJ_SEQFEAT, NULL, NULL);
 
7452
  if (omtp == NULL) return;
 
7453
 
 
7454
  aip = AsnIoNullOpen ();
 
7455
  osd.scp = scp;
 
7456
  
 
7457
  aeop = AsnExpOptNew (aip, NULL, NULL, AsnWriteStringConstraintCallBack);
 
7458
  if (aeop != NULL) {
 
7459
    aeop->user_data = (Pointer) &osd;
 
7460
  }
 
7461
 
 
7462
  for (vnp = feat_list; vnp != NULL; vnp = vnp->next)
 
7463
  {
 
7464
    for (sfp = SeqMgrGetNextFeature (bsp, NULL, 0, vnp->choice, &fcontext);
 
7465
         sfp != NULL;
 
7466
         sfp = SeqMgrGetNextFeature (bsp, sfp, 0, vnp->choice, &fcontext))
 
7467
    {
 
7468
      osd.found = FALSE;
 
7469
      (omtp->asnwrite) (sfp, aip, NULL);
 
7470
      if (osd.found)
 
7471
      {
 
7472
        if (scp->not_present)
 
7473
        {
 
7474
          AsnIoClose (aip);
 
7475
          return FALSE;
 
7476
        }
 
7477
        else
 
7478
        {
 
7479
          AsnIoClose (aip);
 
7480
          return TRUE;
 
7481
        }
 
7482
      }
 
7483
    }
 
7484
  }
 
7485
  AsnIoClose (aip);
 
7486
  if (scp->not_present)
 
7487
  {
 
7488
    return TRUE;
 
7489
  }
 
7490
  else
 
7491
  {
 
7492
    return FALSE;
 
7493
  }
 
7494
}
 
7495
 
 
7496
 
 
7497
typedef struct keywordform 
7419
7498
{
7420
7499
  FORM_MESSAGE_BLOCK
7421
7500
  DialoG string_src_dlg;
7422
7501
  DialoG string_constraint_dlg;
 
7502
  TexT   keyword_txt;
7423
7503
  
7424
7504
  ParseFieldPtr pfp;
7425
7505
  FilterSetPtr  fsp;
7426
 
} StringConstraintFormData, PNTR StringConstraintFormPtr;
7427
 
 
7428
 
 
7429
 
 
7430
 
static void ApplyGDSKeywordCallback (BioseqPtr bsp, Pointer userdata)
 
7506
  CharPtr       keyword;
 
7507
} KeywordFormData, PNTR KeywordFormPtr;
 
7508
 
 
7509
 
 
7510
static void ApplyKeywordCallback (BioseqPtr bsp, Pointer userdata)
7431
7511
{
7432
7512
  SeqEntryPtr             sep;
7433
7513
  ValNodePtr              vnp;
7434
 
  StringConstraintFormPtr scfp;
 
7514
  KeywordFormPtr scfp;
7435
7515
  GBBlockPtr              gbp;
7436
7516
  GetSamplePtr            gsp;
7437
7517
  Boolean                 ok_to_add = TRUE;
7442
7522
    return;
7443
7523
  }
7444
7524
  
7445
 
  scfp = (StringConstraintFormPtr) userdata;
 
7525
  scfp = (KeywordFormPtr) userdata;
7446
7526
  
7447
 
  if (scfp != NULL)
 
7527
  if (scfp->pfp != NULL && scfp->fsp != NULL)
7448
7528
  {
7449
7529
    gsp = GetSampleForSeqEntry (sep, bsp->idx.entityID, scfp->pfp, scfp->fsp);
7450
7530
    if (gsp == NULL || gsp->num_found == 0)
7476
7556
        if (gbp == NULL) return;
7477
7557
        
7478
7558
        for (vnp = gbp->keywords; vnp; vnp = vnp->next) {
7479
 
                if (StringCmp((CharPtr)vnp->data.ptrvalue, "GDS") == 0) {
 
7559
                if (StringCmp((CharPtr)vnp->data.ptrvalue, scfp->keyword) == 0) {
7480
7560
                        return;
7481
7561
                }
7482
7562
        }
7483
 
        ValNodeAddPointer (&(gbp->keywords), 0, StringSave ("GDS"));
 
7563
        ValNodeAddPointer (&(gbp->keywords), 0, StringSave (scfp->keyword));
 
7564
}
 
7565
 
 
7566
static void RemoveKeywordCallback (BioseqPtr bsp, Pointer userdata)
 
7567
{
 
7568
  SeqEntryPtr             sep;
 
7569
  ValNodePtr              vnp, prev_keyword, next_keyword;
 
7570
  KeywordFormPtr scfp;
 
7571
  GBBlockPtr              gbp;
 
7572
  GetSamplePtr            gsp;
 
7573
  Boolean                 ok_to_remove = TRUE;
 
7574
  
 
7575
  sep = SeqMgrGetSeqEntryForData (bsp);
 
7576
  if (sep == NULL)
 
7577
  {
 
7578
    return;
 
7579
  }
 
7580
  
 
7581
  scfp = (KeywordFormPtr) userdata;
 
7582
  
 
7583
  if (scfp->pfp != NULL && scfp->fsp != NULL)
 
7584
  {
 
7585
    gsp = GetSampleForSeqEntry (sep, bsp->idx.entityID, scfp->pfp, scfp->fsp);
 
7586
    if (gsp == NULL || gsp->num_found == 0)
 
7587
    {
 
7588
      ok_to_remove = FALSE;
 
7589
    }
 
7590
    gsp = GetSampleFree (gsp);
 
7591
  }
 
7592
  
 
7593
  if (!ok_to_remove)
 
7594
  {
 
7595
    return;
 
7596
  }
 
7597
      
 
7598
        vnp = GetDescrOnSeqEntry (sep, Seq_descr_genbank);
 
7599
  /* no GenBank descriptor, no keywords to remove */
 
7600
        if (vnp == NULL) return;
 
7601
        
 
7602
        gbp = (GBBlockPtr) vnp->data.ptrvalue;
 
7603
        /* No GBBlock, no keywords to remove */
 
7604
        if (gbp == NULL) return;
 
7605
        
 
7606
  prev_keyword = NULL;
 
7607
        for (vnp = gbp->keywords; vnp; vnp = next_keyword) {
 
7608
          next_keyword = vnp->next;
 
7609
                if (StringICmp((CharPtr)vnp->data.ptrvalue, scfp->keyword) == 0) {
 
7610
                        if (prev_keyword == NULL)
 
7611
                        {
 
7612
                          gbp->keywords = next_keyword;
 
7613
                        }
 
7614
                        else
 
7615
                        {
 
7616
                          prev_keyword->next = next_keyword;
 
7617
                        }
 
7618
                        vnp->next = NULL;
 
7619
                        ValNodeFreeData (vnp);
 
7620
                }
 
7621
                else
 
7622
                {
 
7623
                  prev_keyword = vnp;
 
7624
                }
 
7625
        }
 
7626
}
 
7627
 
 
7628
static void ApplyKeyword (IteM i, CharPtr keyword)
 
7629
{
 
7630
  BaseFormPtr     bfp;
 
7631
  SeqEntryPtr     sep;
 
7632
  KeywordFormData kfd;
 
7633
 
 
7634
#ifdef WIN_MAC
 
7635
  bfp = currentFormDataPtr;
 
7636
#else
 
7637
  bfp = GetObjectExtra (i);
 
7638
#endif
 
7639
  if (bfp == NULL) return;
 
7640
  sep = GetTopSeqEntryForEntityID (bfp->input_entityID);
 
7641
  if (sep == NULL) return;
 
7642
  
 
7643
  kfd.pfp = NULL;
 
7644
  kfd.fsp = NULL;
 
7645
  kfd.keyword = keyword;
 
7646
  
 
7647
  VisitBioseqsInSep (sep, &kfd, ApplyKeywordCallback);
 
7648
 
 
7649
  ObjMgrSetDirtyFlag (bfp->input_entityID, TRUE);
 
7650
  ObjMgrSendMsg (OM_MSG_UPDATE, bfp->input_entityID, 0, 0);
 
7651
  ArrowCursor ();
 
7652
  Update ();   
7484
7653
}
7485
7654
 
7486
7655
extern void ApplyGDSKeyword (IteM i)
7487
7656
{
7488
 
  BaseFormPtr  bfp;
7489
 
  SeqEntryPtr  sep;
7490
 
 
7491
 
#ifdef WIN_MAC
7492
 
  bfp = currentFormDataPtr;
7493
 
#else
7494
 
  bfp = GetObjectExtra (i);
7495
 
#endif
7496
 
  if (bfp == NULL) return;
7497
 
  sep = GetTopSeqEntryForEntityID (bfp->input_entityID);
7498
 
  if (sep == NULL) return;
7499
 
  
7500
 
  VisitBioseqsInSep (sep, NULL, ApplyGDSKeywordCallback);
7501
 
 
7502
 
  ObjMgrSetDirtyFlag (bfp->input_entityID, TRUE);
7503
 
  ObjMgrSendMsg (OM_MSG_UPDATE, bfp->input_entityID, 0, 0);
7504
 
  ArrowCursor ();
7505
 
  Update ();   
7506
 
}
7507
 
 
7508
 
static void DoApplyGDSKeywords (ButtoN b)
7509
 
{
7510
 
  StringConstraintFormPtr scfp;
7511
 
  SeqEntryPtr             sep;
7512
 
  
7513
 
  scfp = (StringConstraintFormPtr) GetObjectExtra (b);
7514
 
  if (scfp == NULL)
7515
 
  {
7516
 
    return;
7517
 
  }
7518
 
  
7519
 
  scfp->pfp = (ParseFieldPtr) DialogToPointer (scfp->string_src_dlg);
7520
 
  scfp->fsp = FilterSetNew ();
7521
 
  scfp->fsp->scp = (StringConstraintPtr) DialogToPointer (scfp->string_constraint_dlg);
7522
 
  
7523
 
  sep = GetTopSeqEntryForEntityID (scfp->input_entityID);
7524
 
  if (sep == NULL) return;
7525
 
  
7526
 
  VisitBioseqsInSep (sep, scfp, ApplyGDSKeywordCallback);
7527
 
 
7528
 
  scfp->fsp = FilterSetFree (scfp->fsp);
7529
 
  scfp->pfp = ParseFieldFree (scfp->pfp);
7530
 
 
7531
 
  ObjMgrSetDirtyFlag (scfp->input_entityID, TRUE);
7532
 
  ObjMgrSendMsg (OM_MSG_UPDATE, scfp->input_entityID, 0, 0);
7533
 
  ArrowCursor ();
7534
 
  Update ();   
7535
 
  Remove (scfp->form);  
7536
 
}
7537
 
 
7538
 
extern void ApplyGDSKeywordWithStringConstraint (IteM i)
7539
 
{
7540
 
  BaseFormPtr             bfp;
7541
 
  StringConstraintFormPtr scfp;
7542
 
  WindoW                  w;
7543
 
  PrompT                  ppt;
7544
 
  GrouP                   h, c;
7545
 
  ButtoN                  b;
7546
 
 
7547
 
#ifdef WIN_MAC
7548
 
  bfp = currentFormDataPtr;
7549
 
#else
7550
 
  bfp = GetObjectExtra (i);
7551
 
#endif
7552
 
  if (bfp == NULL) return;
7553
 
 
7554
 
  scfp = (StringConstraintFormPtr) MemNew (sizeof (StringConstraintFormData));
7555
 
  if (scfp == NULL) return;
7556
 
  
7557
 
  w = FixedWindow (-50, -33, -10, -10, "Apply GDS Keywords", StdCloseWindowProc);
7558
 
  SetObjectExtra (w, scfp, StdCleanupExtraProc);
7559
 
  scfp->form = (ForM) w;
7560
 
  scfp->input_entityID = bfp->input_entityID;
7561
 
  
7562
 
  h = HiddenGroup (w, -1, 0, NULL);
7563
 
  SetGroupSpacing (h, 10, 10);
7564
 
  
7565
 
  ppt = StaticPrompt (h, "Where", 0, 0, programFont, 'l');
7566
 
  scfp->string_src_dlg = ParseFieldDestDialog (h, NULL, NULL);
7567
 
 
7568
 
  scfp->string_constraint_dlg = StringConstraintDialog (h, NULL, FALSE);
7569
 
  
7570
 
  c = HiddenGroup (h, 2, 0, NULL);
7571
 
  b = PushButton (c, "Accept", DoApplyGDSKeywords);
7572
 
  SetObjectExtra (b, scfp, NULL);
7573
 
  b = PushButton (c, "Cancel", StdCancelButtonProc);
7574
 
  
7575
 
  AlignObjects (ALIGN_CENTER, (HANDLE) ppt,
7576
 
                              (HANDLE) scfp->string_src_dlg,
7577
 
                              (HANDLE) scfp->string_constraint_dlg,
7578
 
                              (HANDLE) c,
7579
 
                              NULL);
7580
 
  RealizeWindow (w);
7581
 
  Show (w);
7582
 
  Select (w);
7583
 
  Update ();
7584
 
}
 
7657
  ApplyKeyword (i, "GDS");
 
7658
}
 
7659
 
 
7660
extern void ApplyTPAInferentialKeyword (IteM i)
 
7661
{
 
7662
  ApplyKeyword (i, "TPA:inferential");
 
7663
}
 
7664
 
 
7665
extern void ApplyTPAExperimentalKeyword (IteM i)
 
7666
{
 
7667
  ApplyKeyword (i, "TPA:experimental");
 
7668
}
 
7669
 
 
7670
static void DoApplyKeywords (ButtoN b)
 
7671
{
 
7672
  KeywordFormPtr scfp;
 
7673
  SeqEntryPtr    sep;
 
7674
  
 
7675
  scfp = (KeywordFormPtr) GetObjectExtra (b);
 
7676
  if (scfp == NULL)
 
7677
  {
 
7678
    return;
 
7679
  }
 
7680
  
 
7681
  scfp->pfp = (ParseFieldPtr) DialogToPointer (scfp->string_src_dlg);
 
7682
  scfp->fsp = FilterSetNew ();
 
7683
  scfp->fsp->scp = (StringConstraintPtr) DialogToPointer (scfp->string_constraint_dlg);
 
7684
  scfp->keyword = SaveStringFromText (scfp->keyword_txt);
 
7685
  
 
7686
  sep = GetTopSeqEntryForEntityID (scfp->input_entityID);
 
7687
  if (sep == NULL) return;
 
7688
  
 
7689
  VisitBioseqsInSep (sep, scfp, ApplyKeywordCallback);
 
7690
 
 
7691
  scfp->fsp = FilterSetFree (scfp->fsp);
 
7692
  scfp->pfp = ParseFieldFree (scfp->pfp);
 
7693
 
 
7694
  ObjMgrSetDirtyFlag (scfp->input_entityID, TRUE);
 
7695
  ObjMgrSendMsg (OM_MSG_UPDATE, scfp->input_entityID, 0, 0);
 
7696
  ArrowCursor ();
 
7697
  Update ();   
 
7698
  Remove (scfp->form);  
 
7699
}
 
7700
 
 
7701
extern void ApplyKeywordWithStringConstraint (IteM i)
 
7702
{
 
7703
  BaseFormPtr    bfp;
 
7704
  KeywordFormPtr scfp;
 
7705
  WindoW         w;
 
7706
  PrompT         ppt;
 
7707
  GrouP          h, g, c;
 
7708
  ButtoN         b;
 
7709
 
 
7710
#ifdef WIN_MAC
 
7711
  bfp = currentFormDataPtr;
 
7712
#else
 
7713
  bfp = GetObjectExtra (i);
 
7714
#endif
 
7715
  if (bfp == NULL) return;
 
7716
 
 
7717
  scfp = (KeywordFormPtr) MemNew (sizeof (KeywordFormData));
 
7718
  if (scfp == NULL) return;
 
7719
  
 
7720
  w = FixedWindow (-50, -33, -10, -10, "Apply Keywords", StdCloseWindowProc);
 
7721
  SetObjectExtra (w, scfp, StdCleanupExtraProc);
 
7722
  scfp->form = (ForM) w;
 
7723
  scfp->input_entityID = bfp->input_entityID;
 
7724
  
 
7725
  h = HiddenGroup (w, -1, 0, NULL);
 
7726
  SetGroupSpacing (h, 10, 10);
 
7727
  
 
7728
  g = HiddenGroup (h, 2, 0, NULL);
 
7729
  SetGroupSpacing (g, 10, 10);
 
7730
  StaticPrompt (g, "Apply Keyword", 0, 0, programFont, 'l');
 
7731
  scfp->keyword_txt = DialogText (g, "", 30, NULL);
 
7732
  
 
7733
  ppt = StaticPrompt (h, "Where", 0, 0, programFont, 'l');
 
7734
  scfp->string_src_dlg = ParseFieldDestDialog (h, NULL, NULL);
 
7735
 
 
7736
  scfp->string_constraint_dlg = StringConstraintDialog (h, NULL, FALSE);
 
7737
  
 
7738
  c = HiddenGroup (h, 2, 0, NULL);
 
7739
  b = PushButton (c, "Accept", DoApplyKeywords);
 
7740
  SetObjectExtra (b, scfp, NULL);
 
7741
  b = PushButton (c, "Cancel", StdCancelButtonProc);
 
7742
  
 
7743
  AlignObjects (ALIGN_CENTER, (HANDLE) g,
 
7744
                              (HANDLE) ppt,
 
7745
                              (HANDLE) scfp->string_src_dlg,
 
7746
                              (HANDLE) scfp->string_constraint_dlg,
 
7747
                              (HANDLE) c,
 
7748
                              NULL);
 
7749
  RealizeWindow (w);
 
7750
  Show (w);
 
7751
  Select (w);
 
7752
  Update ();
 
7753
}
 
7754
 
 
7755
static void DoRemoveKeywords (ButtoN b)
 
7756
{
 
7757
  KeywordFormPtr scfp;
 
7758
  SeqEntryPtr    sep;
 
7759
  
 
7760
  scfp = (KeywordFormPtr) GetObjectExtra (b);
 
7761
  if (scfp == NULL)
 
7762
  {
 
7763
    return;
 
7764
  }
 
7765
  
 
7766
  scfp->pfp = (ParseFieldPtr) DialogToPointer (scfp->string_src_dlg);
 
7767
  scfp->fsp = FilterSetNew ();
 
7768
  scfp->fsp->scp = (StringConstraintPtr) DialogToPointer (scfp->string_constraint_dlg);
 
7769
  scfp->keyword = SaveStringFromText (scfp->keyword_txt);
 
7770
  
 
7771
  sep = GetTopSeqEntryForEntityID (scfp->input_entityID);
 
7772
  if (sep == NULL) return;
 
7773
  
 
7774
  VisitBioseqsInSep (sep, scfp, RemoveKeywordCallback);
 
7775
 
 
7776
  scfp->fsp = FilterSetFree (scfp->fsp);
 
7777
  scfp->pfp = ParseFieldFree (scfp->pfp);
 
7778
 
 
7779
  ObjMgrSetDirtyFlag (scfp->input_entityID, TRUE);
 
7780
  ObjMgrSendMsg (OM_MSG_UPDATE, scfp->input_entityID, 0, 0);
 
7781
  ArrowCursor ();
 
7782
  Update ();   
 
7783
  Remove (scfp->form);  
 
7784
}
 
7785
 
 
7786
extern void RemoveKeywordWithStringConstraint (IteM i)
 
7787
{
 
7788
  BaseFormPtr    bfp;
 
7789
  KeywordFormPtr scfp;
 
7790
  WindoW         w;
 
7791
  PrompT         ppt;
 
7792
  GrouP          h, g, c;
 
7793
  ButtoN         b;
 
7794
 
 
7795
#ifdef WIN_MAC
 
7796
  bfp = currentFormDataPtr;
 
7797
#else
 
7798
  bfp = GetObjectExtra (i);
 
7799
#endif
 
7800
  if (bfp == NULL) return;
 
7801
 
 
7802
  scfp = (KeywordFormPtr) MemNew (sizeof (KeywordFormData));
 
7803
  if (scfp == NULL) return;
 
7804
  
 
7805
  w = FixedWindow (-50, -33, -10, -10, "Remove Keywords", StdCloseWindowProc);
 
7806
  SetObjectExtra (w, scfp, StdCleanupExtraProc);
 
7807
  scfp->form = (ForM) w;
 
7808
  scfp->input_entityID = bfp->input_entityID;
 
7809
  
 
7810
  h = HiddenGroup (w, -1, 0, NULL);
 
7811
  SetGroupSpacing (h, 10, 10);
 
7812
  
 
7813
  g = HiddenGroup (h, 2, 0, NULL);
 
7814
  SetGroupSpacing (g, 10, 10);
 
7815
  StaticPrompt (g, "Remove Keyword", 0, 0, programFont, 'l');
 
7816
  scfp->keyword_txt = DialogText (g, "", 30, NULL);
 
7817
  
 
7818
  ppt = StaticPrompt (h, "Where", 0, 0, programFont, 'l');
 
7819
  scfp->string_src_dlg = ParseFieldDestDialog (h, NULL, NULL);
 
7820
 
 
7821
  scfp->string_constraint_dlg = StringConstraintDialog (h, NULL, FALSE);
 
7822
  
 
7823
  c = HiddenGroup (h, 2, 0, NULL);
 
7824
  b = PushButton (c, "Accept", DoRemoveKeywords);
 
7825
  SetObjectExtra (b, scfp, NULL);
 
7826
  b = PushButton (c, "Cancel", StdCancelButtonProc);
 
7827
  
 
7828
  AlignObjects (ALIGN_CENTER, (HANDLE) g,
 
7829
                              (HANDLE) ppt,
 
7830
                              (HANDLE) scfp->string_src_dlg,
 
7831
                              (HANDLE) scfp->string_constraint_dlg,
 
7832
                              (HANDLE) c,
 
7833
                              NULL);
 
7834
  RealizeWindow (w);
 
7835
  Show (w);
 
7836
  Select (w);
 
7837
  Update ();
 
7838
}
 
7839
 
7585
7840
 
7586
7841
#if defined(OS_UNIX) || defined(OS_MSWIN)
7587
7842
 
7601
7856
  Int4       num_sequences;
7602
7857
  BoolPtr    selected;
7603
7858
  Int2       lineheight;  
 
7859
  CharPtr    database;
7604
7860
} RNAStrandData, PNTR RNAStrandPtr;
7605
7861
 
7606
 
static void GetAccessionList (BioseqPtr bsp, Pointer userdata)
7607
 
{
7608
 
  ValNodePtr PNTR sequence_list;
7609
 
  SeqIdPtr        sip;
7610
 
  
7611
 
  if (bsp == NULL || userdata == NULL) return;
7612
 
  
7613
 
  sequence_list = (ValNodePtr PNTR) userdata;
7614
 
  
7615
 
  for (sip = bsp->id; sip != NULL; sip = sip->next)
7616
 
  {
7617
 
    if (sip->choice == SEQID_GENBANK)
7618
 
    {
7619
 
      ValNodeAddPointer (sequence_list, 0, sip);
7620
 
      return;
7621
 
    }
7622
 
  }
7623
 
}
7624
 
 
7625
7862
typedef enum 
7626
7863
{
7627
7864
  RNAstrand_PLUS = 1,
7637
7874
{ "Plus", "Minus", "Mixed", "No Hits", "Unexpected", "Parse Error", "In Progress" };
7638
7875
 
7639
7876
 
7640
 
/* Looks at a portion of the list of sequences for strand correction.
7641
 
 * Returns the number of sequences examined.
7642
 
 */
7643
 
static Int4 
7644
 
GetSubListForRNAStrandCorrection 
7645
 
(ValNodePtr start_list,
7646
 
 Int4       num_seqs,
7647
 
 CharPtr    RNAstrandcmd)
7648
 
{
7649
 
  Int4                    seq_num, cmd_len = 0, k;
7650
 
  ValNodePtr              vnp;
7651
 
  FILE *                  fp;
7652
 
  CharPtr                 args = NULL, cp, cp2, cmmd;
7653
 
  Char                    tmp_id [256];
7654
 
  Char                    path [PATH_MAX];
7655
 
  Char                    file_line [256];
7656
 
  Boolean                 found_id;
7657
 
#ifdef OS_UNIX
7658
 
  CharPtr                 cmd_format = "%s -a \'%s\' > %s";
7659
 
#endif
7660
 
#ifdef OS_MSWIN
7661
 
  CharPtr                 cmd_format = "%s -a \"%s\" > %s";
7662
 
#endif
7663
 
 
7664
 
  if (start_list == NULL || num_seqs < 1 || StringHasNoText (RNAstrandcmd))
7665
 
  {
7666
 
    return 0;
7667
 
  }
7668
 
 
7669
 
  TmpNam (path);
7670
 
  
7671
 
  /* calculate length of string needed for command */
7672
 
  for (vnp = start_list, seq_num = 0; 
7673
 
           vnp != NULL && seq_num < num_seqs; 
7674
 
           vnp = vnp->next, seq_num++)
7675
 
  {
7676
 
    SeqIdWrite (vnp->data.ptrvalue, tmp_id, PRINTID_TEXTID_ACC_ONLY, sizeof (tmp_id) - 1);
7677
 
    cmd_len += StringLen (tmp_id) + 2;
7678
 
  }
7679
 
  
7680
 
  args = (CharPtr) MemNew (cmd_len * sizeof (Char));
7681
 
  if (args == NULL)
7682
 
  {
7683
 
        Message (MSG_ERROR, "Unable to allocate memory for strand script argument list");
7684
 
    return 0;
7685
 
  }
7686
 
  
7687
 
  cp = args;
7688
 
  for (vnp = start_list, seq_num = 0; 
7689
 
           vnp != NULL && seq_num < num_seqs; 
7690
 
           vnp = vnp->next, seq_num++)
7691
 
  {
7692
 
    SeqIdWrite (vnp->data.ptrvalue, cp, PRINTID_TEXTID_ACC_ONLY, cmd_len - (cp - args) - 1);
7693
 
    cp += StringLen (cp);
7694
 
    if (vnp->next != NULL && seq_num < num_seqs - 1)
7695
 
    {
7696
 
#ifdef OS_UNIX
7697
 
      StringCat (cp, ",");
7698
 
      cp ++;
7699
 
#else
7700
 
      StringCat (cp, ", ");
7701
 
      cp += 2;
7702
 
#endif
7703
 
    }
7704
 
  }
7705
 
  
7706
 
  cmd_len += 3 + StringLen (cmd_format) + StringLen (RNAstrandcmd) + StringLen (path);
7707
 
  cmmd = (CharPtr) MemNew (cmd_len * sizeof (Char));
7708
 
  if (cmmd == NULL)
7709
 
  {
7710
 
    args = MemFree (args);
7711
 
        Message (MSG_ERROR, "Unable to allocate memory for RNA strand script command");
7712
 
    return 0;
7713
 
  }
7714
 
  
7715
 
  sprintf (cmmd, cmd_format, RNAstrandcmd, args, path);
7716
 
  system (cmmd);
7717
 
  
7718
 
  args = MemFree (args);
7719
 
  cmmd = MemFree (cmmd);
7720
 
  
7721
 
  fp = FileOpen (path, "r");
7722
 
  if (fp == NULL) {
7723
 
    FileRemove (path);
7724
 
    return 0;
7725
 
  }
7726
 
  
7727
 
 
7728
 
  while (fgets (file_line, sizeof (file_line) - 1, fp) != NULL)
7729
 
  {
7730
 
    /* find SeqId that matches file line */
7731
 
    cp = StringChr (file_line, '\t');
7732
 
    if (cp == NULL)
7733
 
    {
7734
 
      continue;
7735
 
    }
7736
 
    *cp = 0;
7737
 
    cp++;
7738
 
    cp2 = StringChr (cp, '\n');
7739
 
    if (cp2 != NULL)
7740
 
    {
7741
 
      *cp2 = 0;
7742
 
    }
7743
 
    found_id = FALSE;
7744
 
    for (vnp = start_list, seq_num = 0; 
7745
 
             vnp != NULL && seq_num < num_seqs; 
7746
 
             vnp = vnp->next, seq_num++)
7747
 
        {
7748
 
      SeqIdWrite (vnp->data.ptrvalue, tmp_id, PRINTID_TEXTID_ACC_ONLY, sizeof (tmp_id) - 1);
7749
 
      if (StringCmp (tmp_id, file_line) == 0)
7750
 
      {
7751
 
        for (k = 1; k <= RNAstrand_IN_PROGRESS; k++)
7752
 
        {
7753
 
          if (StringCmp (cp, RNAstrand_strings [k - 1]) == 0
7754
 
              || (k == RNAstrand_MIXED 
7755
 
                  && StringNCmp (cp, RNAstrand_strings [k - 1], 
7756
 
                                 StringLen (RNAstrand_strings[k - 1])) == 0))
7757
 
          {
7758
 
            vnp->choice = k;
7759
 
          }
7760
 
        }
7761
 
      }
7762
 
    }
7763
 
  }
7764
 
  
7765
 
  FileClose (fp);
7766
 
 
7767
 
  FileRemove (path);
7768
 
  return seq_num;
7769
 
}
7770
 
 
7771
 
static ValNodePtr GetListForRNAStrandCorrection (SeqEntryPtr sep)
7772
 
{
7773
 
  Char                    file_line [256];
7774
 
  ValNodePtr              sequence_list = NULL, vnp;
7775
 
  Int4                    num_sequences = 0, num_inspected; 
7776
 
 
 
7877
static void LimitAlignmentResults (SeqAlignPtr salp, Int4 num_results)
 
7878
{
 
7879
  Int4        k = 0;
 
7880
  SeqAlignPtr tmp_salp, last_salp = NULL;
 
7881
  
 
7882
  while (salp != NULL && k < num_results)
 
7883
  {
 
7884
    last_salp = salp;
 
7885
    salp = salp->next;
 
7886
    k++;
 
7887
  }
 
7888
  if (last_salp != NULL)
 
7889
  {
 
7890
    last_salp->next = NULL;
 
7891
  }
 
7892
  while (salp != NULL)
 
7893
  {
 
7894
    tmp_salp = salp->next;
 
7895
    salp->next = NULL;
 
7896
    salp = SeqAlignFree (salp);
 
7897
    salp = tmp_salp;
 
7898
  }
 
7899
}
 
7900
 
 
7901
 
 
7902
static SBlastOptions*
 
7903
RNABlastOptionNew(void)
 
7904
 
 
7905
{
 
7906
        SBlastOptions* options;
 
7907
        Int2           rval;
 
7908
        Blast_SummaryReturn *extra_returns;
 
7909
 
 
7910
 
 
7911
  extra_returns = Blast_SummaryReturnNew();
 
7912
  rval = SBlastOptionsNew("blastn", &options,
 
7913
                          extra_returns);
 
7914
 
 
7915
        if (options == NULL)
 
7916
                return NULL;
 
7917
 
 
7918
  /* This replaces:
 
7919
   * options->expect_value = 1; 
 
7920
   */
 
7921
  SBlastOptionsSetEvalue(options, 1);
 
7922
 
 
7923
  /* This replaces:
 
7924
   * options->filter_string = StringSave("m L"); 
 
7925
   */
 
7926
  SBlastOptionsSetFilterString(options, "m L");
 
7927
  
 
7928
  /* This replaces the following:
 
7929
   * options->mb_template_length = 18;
 
7930
   * options->mb_disc_type = MB_WORD_CODING; 
 
7931
   * options->is_megablast_search = TRUE;
 
7932
   * options->discontinuous = TRUE;
 
7933
   */
 
7934
  SBlastOptionsSetDiscMbParams(options, 18, MB_WORD_CODING);
 
7935
 
 
7936
  /* This replaces:
 
7937
   * options->wordsize = 11; \
 
7938
   */
 
7939
        SBlastOptionsSetWordSize (options, 11);
 
7940
        
 
7941
  /* This replaces:
 
7942
   * options->hitlist_size = 20; 
 
7943
   */
 
7944
  options->hit_options->hitlist_size = 20;
 
7945
  
 
7946
  /* This replaces the following:
 
7947
   * options->multiple_hits_only  = TRUE;
 
7948
   * options->window_size = 40; 
 
7949
   */
 
7950
  options->word_options->window_size = 40;
 
7951
  
 
7952
  /* This replaces the following:
 
7953
   * options->reward = 1;
 
7954
         * options->penalty = -3;
 
7955
         * options->gap_open = 5;
 
7956
         * options->gap_extend = 2; 
 
7957
         */
 
7958
  SBlastOptionsSetRewardPenaltyAndGapCosts(options, 1, -3, 5, 2, FALSE);
 
7959
        
 
7960
        extra_returns = Blast_SummaryReturnFree(extra_returns);
 
7961
        return options;
 
7962
}
 
7963
 
 
7964
 
 
7965
static Int4
 
7966
RNAScreenSequence(BioseqPtr bsp, CharPtr database, SeqAlignPtr PNTR seqalign_ptr)
 
7967
 
 
7968
{
 
7969
        SBlastOptions *blast_options;
 
7970
        Int2 retval=0;
 
7971
        SeqAlignPtr seqalign = NULL;
 
7972
        SeqLocPtr   slp;
 
7973
        SBlastSeqalignArray* seqalign_arr = NULL;
 
7974
        Blast_SummaryReturn *extra_returns;
 
7975
 
 
7976
        if (bsp == NULL)
 
7977
                return -1;
 
7978
 
 
7979
        if (seqalign_ptr)
 
7980
                *seqalign_ptr = NULL;
 
7981
 
 
7982
        blast_options = RNABlastOptionNew();
 
7983
        if (blast_options == NULL)
 
7984
                return -1;
 
7985
        
 
7986
        slp = SeqLocWholeNew(bsp);
 
7987
        if (database == NULL) 
 
7988
          database = "16Score";
 
7989
        
 
7990
        extra_returns = Blast_SummaryReturnNew();
 
7991
 
 
7992
  retval = Blast_DatabaseSearch(slp, database, NULL, blast_options, NULL, &seqalign_arr, NULL, extra_returns);
 
7993
        extra_returns = Blast_SummaryReturnFree(extra_returns);
 
7994
        blast_options = SBlastOptionsFree(blast_options);  
 
7995
        
 
7996
        if (retval == 0 && seqalign_arr != NULL && seqalign_arr->num_queries >0)
 
7997
        {
 
7998
          seqalign = seqalign_arr->array[0];
 
7999
          seqalign_arr->array[0] = NULL;
 
8000
        }
 
8001
        
 
8002
        seqalign_arr = SBlastSeqalignArrayFree(seqalign_arr);
 
8003
        
 
8004
        /* limit results to first 20 alignments, as SMART does */
 
8005
        LimitAlignmentResults (seqalign, 20);   
 
8006
        
 
8007
        if (seqalign)
 
8008
        {
 
8009
                if (seqalign_ptr)
 
8010
                        *seqalign_ptr = seqalign;
 
8011
        }       
 
8012
 
 
8013
 
 
8014
        return retval;
 
8015
}
 
8016
 
 
8017
 
 
8018
typedef struct rnastrandcollection
 
8019
{
 
8020
  ValNodePtr sequence_list;
 
8021
  Char       path [PATH_MAX];
 
8022
  CharPtr    database;
 
8023
  Int4       count;
 
8024
  Int4       total;
 
8025
  MonitorPtr mon;
 
8026
} RNAStrandCollectionData, PNTR RNAStrandCollectionPtr;
 
8027
 
 
8028
static Uint1 GetStatusForAlignmentList (SeqAlignPtr salp)
 
8029
{
 
8030
  Uint1 status = RNAstrand_NO_HITS;
 
8031
  Uint1 strand;
 
8032
  
 
8033
  while (salp != NULL)
 
8034
  {
 
8035
    AlnMgr2IndexSingleChildSeqAlign(salp);
 
8036
    strand = AlnMgr2GetNthStrand(salp, 1);
 
8037
    if (status == RNAstrand_NO_HITS)
 
8038
    {
 
8039
      if (strand == Seq_strand_plus)
 
8040
      {
 
8041
        status = RNAstrand_PLUS;
 
8042
      }
 
8043
      else if (strand == Seq_strand_minus)
 
8044
      {
 
8045
        status = RNAstrand_MINUS;
 
8046
      }
 
8047
      else
 
8048
      {
 
8049
        return RNAstrand_UNEXPECTED;
 
8050
      }
 
8051
    }
 
8052
    else if (strand == Seq_strand_plus)
 
8053
    {
 
8054
      if (status != RNAstrand_PLUS)
 
8055
      {
 
8056
        return RNAstrand_MIXED;
 
8057
      }
 
8058
    }
 
8059
    else if (strand == Seq_strand_minus)
 
8060
    {
 
8061
      if (status != RNAstrand_MINUS)
 
8062
      {
 
8063
        return RNAstrand_MIXED;
 
8064
      }
 
8065
    }
 
8066
    else
 
8067
    {
 
8068
      return RNAstrand_UNEXPECTED;
 
8069
    }
 
8070
    salp = salp->next;
 
8071
  }
 
8072
  return status;  
 
8073
}
 
8074
 
 
8075
static void GetOneRNAStrandednessInfo (BioseqPtr bsp, Pointer userdata)
 
8076
{
 
8077
  RNAStrandCollectionPtr rscp;
 
8078
  SeqAlignPtr            salp = NULL;
 
8079
  
 
8080
  if (bsp == NULL || !ISA_na (bsp->mol) || userdata == NULL)
 
8081
  {
 
8082
    return;
 
8083
  }
 
8084
  
 
8085
  rscp = (RNAStrandCollectionPtr) userdata;
 
8086
 
 
8087
  if (rscp->mon != NULL) {
 
8088
    MonitorIntValue (rscp->mon, rscp->count);
 
8089
  }
 
8090
  (rscp->count)++;
 
8091
  
 
8092
  RNAScreenSequence(bsp, rscp->path, &salp);
 
8093
 
 
8094
  ValNodeAddPointer (&(rscp->sequence_list), 
 
8095
                     GetStatusForAlignmentList(salp),
 
8096
                     SeqIdFindBest (bsp->id, SEQID_GENBANK));
 
8097
  salp = SeqAlignFree (salp);  
 
8098
}
 
8099
 
 
8100
static void CountRNASequences (BioseqPtr bsp, Pointer userdata)
 
8101
{
 
8102
  RNAStrandCollectionPtr rscp;
 
8103
 
 
8104
  if (bsp == NULL || !ISA_na (bsp->mol) || userdata == NULL)
 
8105
  {
 
8106
    return;
 
8107
  }
 
8108
  
 
8109
  rscp = (RNAStrandCollectionPtr) userdata;
 
8110
  
 
8111
  rscp->total++;  
 
8112
}
 
8113
 
 
8114
static ValNodePtr GetRNAStrandednessFromLocalDatabase (SeqEntryPtr sep, CharPtr database)
 
8115
{
 
8116
  RNAStrandCollectionData rscd;
 
8117
  
7777
8118
  if (sep == NULL) return NULL;
7778
8119
 
7779
 
  if (RNAstrandcmd == NULL) {
7780
 
    if (GetAppParam ("SEQUIN", "RNACORRECT", "RNASTRAND", NULL, file_line, sizeof (file_line))) {
7781
 
        RNAstrandcmd = StringSaveNoNull (file_line);
7782
 
    }
7783
 
  }
7784
 
  if (RNAstrandcmd == NULL)
7785
 
  {
7786
 
    Message (MSG_ERROR, "RNASTRAND not set in config file!");
7787
 
    return NULL;
7788
 
  }
7789
 
  
7790
 
  
7791
 
  VisitBioseqsInSep (sep, &sequence_list, GetAccessionList);
7792
 
 
7793
 
  if (sequence_list == NULL)
7794
 
  {
7795
 
    Message (MSG_ERROR, "No sequences with accession numbers found!\n");
7796
 
    return NULL;
7797
 
  }
7798
 
  
7799
 
  vnp = sequence_list;
7800
 
  while ((num_inspected = GetSubListForRNAStrandCorrection (vnp, 150, RNAstrandcmd)) != 0)
7801
 
  {
7802
 
    num_sequences += num_inspected;
7803
 
        while (num_inspected > 0 && vnp != NULL)
7804
 
        {
7805
 
          vnp = vnp->next;
7806
 
          num_inspected --;
7807
 
        }
7808
 
  }
7809
 
 
7810
 
  return sequence_list;  
 
8120
  rscd.path [0] = '\0';
 
8121
  GetAppParam ("NCBI", "NCBI", "DATA", "", rscd.path, sizeof (rscd.path));
 
8122
  FileBuildPath (rscd.path, NULL, database);
 
8123
  
 
8124
  rscd.database = database;
 
8125
  rscd.sequence_list = NULL;
 
8126
  rscd.total = 0;
 
8127
  rscd.count = 0;
 
8128
  rscd.mon = NULL;
 
8129
  
 
8130
  VisitBioseqsInSep (sep, &rscd, CountRNASequences);
 
8131
  if (rscd.total > 2)
 
8132
  {
 
8133
    rscd.mon = MonitorIntNewEx ("RNA Strand Progress", 0, rscd.total - 1, FALSE);
 
8134
  }
 
8135
  
 
8136
  VisitBioseqsInSep (sep, &rscd, GetOneRNAStrandednessInfo);  
 
8137
  
 
8138
  if (rscd.mon != NULL) {
 
8139
    rscd.mon = MonitorFree (rscd.mon);
 
8140
    Update ();
 
8141
  }
 
8142
  
 
8143
  return rscd.sequence_list;
7811
8144
}
7812
8145
 
 
8146
 
7813
8147
static void DoOneReverse (ValNodePtr vnp, Boolean rev_feats)
7814
8148
{
7815
8149
  BioseqPtr    bsp;
8036
8370
  }
8037
8371
}
8038
8372
 
8039
 
static void RefreshRNAStrandDialog (ButtoN b)
 
8373
static void RedrawRNAStrandDialog (RNAStrandPtr strand_info)
8040
8374
{
8041
 
  RNAStrandPtr strand_info;
8042
8375
  Int4         strand_num;
8043
 
  Char                    doc_line [500];
8044
 
  ValNodePtr   new_seq_list, vnp;
 
8376
  Char         doc_line [500];
 
8377
  ValNodePtr   vnp;
8045
8378
  
8046
 
  strand_info = (RNAStrandPtr) GetObjectExtra (b);
8047
8379
  if (strand_info == NULL)
8048
8380
  {
8049
8381
    return;
8050
8382
  }
8051
 
  
8052
 
  new_seq_list = GetListForRNAStrandCorrection (strand_info->sep);
8053
 
  
8054
 
  if (new_seq_list == NULL)
8055
 
  {
8056
 
    Message (MSG_ERROR, "Unable to refresh sequence list.");
8057
 
    return;
8058
 
  }
8059
 
  strand_info->sequence_list = ValNodeFree (strand_info->sequence_list);
8060
 
  strand_info->sequence_list = new_seq_list;
8061
 
    
 
8383
 
8062
8384
  Reset (strand_info->doc);
8063
8385
  /* print out minus strands */
8064
8386
  for (vnp = strand_info->sequence_list, strand_num = 0;
8113
8435
    AppendText (strand_info->doc, doc_line, &(strand_info->rnaParFmt), strand_info->rnaColFmt, programFont);
8114
8436
  }
8115
8437
 
8116
 
  UpdateDocument (strand_info->doc, 0, 0);
8117
 
  
8118
 
}
 
8438
  UpdateDocument (strand_info->doc, 0, 0);  
 
8439
}
 
8440
 
 
8441
static void RefreshRNAStrandDialog (ButtoN b)
 
8442
{
 
8443
  RNAStrandPtr strand_info;
 
8444
  ValNodePtr   new_seq_list;
 
8445
  
 
8446
  strand_info = (RNAStrandPtr) GetObjectExtra (b);
 
8447
  if (strand_info == NULL)
 
8448
  {
 
8449
    return;
 
8450
  }
 
8451
  
 
8452
  new_seq_list = GetRNAStrandednessFromLocalDatabase (strand_info->sep, strand_info->database); 
 
8453
  
 
8454
  if (new_seq_list == NULL)
 
8455
  {
 
8456
    Message (MSG_ERROR, "Unable to refresh sequence list.");
 
8457
    return;
 
8458
  }
 
8459
  strand_info->sequence_list = ValNodeFree (strand_info->sequence_list);
 
8460
  strand_info->sequence_list = new_seq_list;
 
8461
    
 
8462
  RedrawRNAStrandDialog (strand_info);
 
8463
}
 
8464
 
8119
8465
 
8120
8466
extern Int2 LIBCALLBACK CorrectRNAStrandedness (Pointer data)
8121
8467
 
8140
8486
  sep = GetTopSeqEntryForEntityID (ompcp->input_entityID);
8141
8487
  if (sep == NULL) return OM_MSG_RET_ERROR;
8142
8488
 
8143
 
  sequence_list = GetListForRNAStrandCorrection (sep);
 
8489
  sequence_list = GetRNAStrandednessFromLocalDatabase (sep, "16Score"); 
8144
8490
  
8145
8491
  if (sequence_list == NULL)
8146
8492
  {
8158
8504
  strand_info->sequence_list = sequence_list;
8159
8505
  strand_info->num_sequences = ValNodeLen (sequence_list);
8160
8506
  strand_info->selected = (BoolPtr) MemNew (strand_info->num_sequences * sizeof (Boolean));
 
8507
  strand_info->database = "16Score";
8161
8508
 
8162
8509
  /* initialize document paragraph format */
8163
8510
  strand_info->rnaParFmt.openSpace = FALSE;
8240
8587
                              (HANDLE) strand_info->rev_feats,
8241
8588
                              (HANDLE) c,
8242
8589
                              NULL);  
8243
 
  RefreshRNAStrandDialog (refresh_btn);
 
8590
  RedrawRNAStrandDialog (strand_info);
8244
8591
  Show (w);
8245
8592
  return OM_MSG_RET_OK;
8246
8593
}
8277
8624
  return val;
8278
8625
}
8279
8626
 
 
8627
static Int4 GetYearFromNumber(Int4 year)
 
8628
{
 
8629
        Nlm_DayTime dt;
 
8630
 
 
8631
  if (year < 1000)
 
8632
  {
 
8633
    GetDayTime (&dt);
 
8634
    if (year + 2000 > dt.tm_year + 1)
 
8635
    {
 
8636
      year += 1900;
 
8637
    }
 
8638
    else
 
8639
    {
 
8640
      year += 2000;
 
8641
    }
 
8642
  }
 
8643
  return year;
 
8644
}
 
8645
 
8280
8646
static Int4 GetYearFromToken (CharPtr token, Int4 token_len)
8281
8647
{
8282
 
  Int4     year = 0;
 
8648
  Int4        year = 0;
8283
8649
  
8284
8650
  if (token == NULL || token_len == 0 || token_len > 4)
8285
8651
  {
8286
8652
    return 0;
8287
8653
  }
8288
8654
  
8289
 
  year = ReadNumberFromToken (token, token_len);
8290
 
  if (year < 1000)
8291
 
  {
8292
 
    year += 2000;
8293
 
  }
 
8655
  year = GetYearFromNumber(ReadNumberFromToken (token, token_len));
8294
8656
  
8295
8657
  return year;
8296
8658
}
8449
8811
  }
8450
8812
  else if (num_1 > 12)
8451
8813
  {
8452
 
    *year = num_1;
8453
 
    if (*year < 1000)
8454
 
    {
8455
 
      *year += 2000;
8456
 
    }
 
8814
    *year = GetYearFromNumber(num_1);
8457
8815
    *month = month_abbrevs [num_2 - 1];
8458
8816
  }
8459
8817
  else if (num_2 > 12)
8460
8818
  {
8461
 
    *year = num_2;
8462
 
    if (*year < 1000)
8463
 
    {
8464
 
      *year += 2000;
8465
 
    }
 
8819
    *year = GetYearFromNumber(num_2);
8466
8820
    *month = month_abbrevs [num_1 - 1];
8467
8821
  }
8468
8822
  else if (month_first)
8469
8823
  {
8470
 
    *year = num_2;
8471
 
    if (*year < 1000)
8472
 
    {
8473
 
      *year += 2000;
8474
 
    }
 
8824
    *year = GetYearFromNumber(num_2);
8475
8825
    *month = month_abbrevs [num_1 - 1];
8476
8826
  }
8477
8827
  else
8478
8828
  {
8479
 
    *year = num_1;
8480
 
    if (*year < 1000)
8481
 
    {
8482
 
      *year += 2000;
8483
 
    }
 
8829
    *year = GetYearFromNumber(num_1);
8484
8830
    *month = month_abbrevs [num_2 - 1];
8485
8831
  }
8486
8832
  return TRUE;
8731
9077
      }
8732
9078
                
8733
9079
    }
8734
 
    if (year < 1000)
8735
 
    {
8736
 
      year += 2000;
8737
 
    }
 
9080
    year = GetYearFromNumber(year);
8738
9081
  }
8739
9082
  
8740
9083
  if (month == NULL && day > 0)
8888
9231
  ParseCollectionDate (i, FALSE);
8889
9232
}
8890
9233
 
 
9234
 
 
9235
static CharPtr GetIDStringForSeqEntry (SeqEntryPtr sep)
 
9236
{
 
9237
  BioseqSetPtr bssp;
 
9238
  BioseqPtr    bsp = NULL;
 
9239
  SeqIdPtr     sip = NULL;
 
9240
  Char         id_txt [100];
 
9241
  
 
9242
  if (sep == NULL || sep->data.ptrvalue == NULL)
 
9243
  {
 
9244
    return NULL;
 
9245
  }
 
9246
  
 
9247
  if (IS_Bioseq_set (sep))
 
9248
  {
 
9249
    bssp = (BioseqSetPtr) sep->data.ptrvalue;
 
9250
    if (bssp->_class == BioseqseqSet_class_nuc_prot
 
9251
        || bssp->_class == BioseqseqSet_class_segset)
 
9252
    {
 
9253
      sep = bssp->seq_set;
 
9254
      while (sep != NULL && (IS_Bioseq_set (sep) || sep->data.ptrvalue == NULL))
 
9255
      {
 
9256
        sep = sep->next;
 
9257
      }
 
9258
      if (sep != NULL)
 
9259
      {
 
9260
        bsp = (BioseqPtr) sep->data.ptrvalue;
 
9261
      }
 
9262
    }
 
9263
  }
 
9264
  else if (IS_Bioseq(sep))
 
9265
  {
 
9266
    bsp = (BioseqPtr) sep->data.ptrvalue;
 
9267
  }
 
9268
  if (bsp == NULL) return NULL;
 
9269
  sip = SeqIdFindBest (bsp->id, SEQID_GENBANK);
 
9270
  if (sip == NULL) return NULL;
 
9271
  
 
9272
  SeqIdWrite (sip, id_txt, PRINTID_REPORT, sizeof (id_txt) - 1);
 
9273
  return StringSave (id_txt);
 
9274
}
 
9275
 
 
9276
 
 
9277
static int LIBCALLBACK SortSeqEntryByIDStr (VoidPtr ptr1, VoidPtr ptr2)
 
9278
 
 
9279
{
 
9280
  CharPtr     str1;
 
9281
  CharPtr     str2;
 
9282
  ValNodePtr  vnp1;
 
9283
  ValNodePtr  vnp2;
 
9284
  int         rval = 0;
 
9285
 
 
9286
  if (ptr1 != NULL && ptr2 != NULL) {
 
9287
    vnp1 = *((ValNodePtr PNTR) ptr1);
 
9288
    vnp2 = *((ValNodePtr PNTR) ptr2);
 
9289
    if (vnp1 != NULL && vnp2 != NULL) {
 
9290
      str1 = GetIDStringForSeqEntry (vnp1);
 
9291
      str2 = GetIDStringForSeqEntry (vnp2);
 
9292
      if (str1 != NULL && str2 != NULL) {
 
9293
        rval = StringICmp (str1, str2);
 
9294
      }
 
9295
      str1 = MemFree (str1);
 
9296
      str2 = MemFree (str2);
 
9297
    }
 
9298
  }
 
9299
  return rval;
 
9300
}
 
9301
 
 
9302
 
 
9303
extern Int2 LIBCALLBACK ReorderSetByAccession (Pointer data)
 
9304
{
 
9305
  BioseqSetPtr      bssp;
 
9306
  OMProcControlPtr  ompcp;
 
9307
  ObjMgrDataPtr     omdptop;
 
9308
  ObjMgrData        omdata;
 
9309
  Uint2             parenttype;
 
9310
  Pointer           parentptr;
 
9311
  SeqEntryPtr       sep;
 
9312
 
 
9313
  /* Check parameters and get a pointer to the current data */
 
9314
 
 
9315
  ompcp = (OMProcControlPtr) data;
 
9316
  if (ompcp == NULL)
 
9317
    return OM_MSG_RET_ERROR;
 
9318
 
 
9319
  if (ompcp->input_itemtype != OBJ_BIOSEQSET || ompcp->input_data == NULL) {
 
9320
    Message (MSG_ERROR, "Must select Bioseq Set!");
 
9321
    return OM_MSG_RET_ERROR;
 
9322
  }
 
9323
  
 
9324
  bssp = (BioseqSetPtr) ompcp->input_data;
 
9325
  sep = SeqMgrGetSeqEntryForData (bssp);
 
9326
  SaveSeqEntryObjMgrData (sep, &omdptop, &omdata);
 
9327
  GetSeqEntryParent (sep, &parentptr, &parenttype);  
 
9328
 
 
9329
  bssp->seq_set = ValNodeSort (bssp->seq_set, SortSeqEntryByIDStr);
 
9330
  
 
9331
  
 
9332
  SeqMgrLinkSeqEntry (sep, parenttype, parentptr);
 
9333
  RestoreSeqEntryObjMgrData (sep, omdptop, &omdata); 
 
9334
  ObjMgrSetDirtyFlag (ompcp->input_entityID, TRUE);
 
9335
  ObjMgrSendMsg (OM_MSG_UPDATE, ompcp->input_entityID, 0, 0);  
 
9336
}
 
9337