← Back to branch summary

~ubuntu-branches/ubuntu/hardy/ncbi-tools6/hardy

« back to all changes in this revision

Viewing changes to desktop/dlgutil1.c

  • Committer: Bazaar Package Importer
  • Author(s): Aaron M. Ucko
  • Date: 2007-10-26 19:27:01 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20071026192701-qt697jomcoz75ftt
Tags: 6.1.20070822-2
http://bugs.debian.org/448031
* debian/control: set Homepage.
* debian/{control,makemenu,rules,*.desktop.in}: supply XDG desktop
  entries and icons for inherently graphical apps.  (Closes: #448031.)
* debian/{man.unused,old-blast-man,shlibs.local}: remove (obsolete
  cruft; shlibs.local contained only comments anyway.)

Show diffs side-by-side

added added

removed removed

Lines of Context:
desktop/dlgutil1.c
29
29
*
30
30
* Version Creation Date:   1/22/95
31
31
*
32
 
* $Revision: 6.103 $
 
32
* $Revision: 6.126 $
33
33
*
34
34
* File Description: 
35
35
*
54
54
#include <sqnutils.h>
55
55
#include <alignmgr2.h>
56
56
#include <toasn3.h>
 
57
#include <vibforms.h>
57
58
 
58
59
#define NUMBER_OF_SUFFIXES    8
59
60
 
312
313
 
313
314
{
314
315
  BaseFormPtr    bfp;
315
 
  Int2           j;
316
 
  Int2           num;
 
316
  Uint4          j;
 
317
  Uint4          num;
317
318
  ObjMgrPtr      omp;
318
319
  ObjMgrDataPtr  PNTR omdpp;
319
320
  OMUserDataPtr  omudp;
353
354
 
354
355
{
355
356
  BaseFormPtr    bfp;
356
 
  Int2           j;
357
 
  Int2           num;
 
357
  Uint4          j;
 
358
  Uint4          num;
358
359
  ObjMgrPtr      omp;
359
360
  ObjMgrDataPtr  PNTR omdpp;
360
361
  OMUserDataPtr  omudp;
418
419
 
419
420
extern Boolean MakeViewerIndependent (Uint2 entityID, OMUserDataPtr omudp)
420
421
{
421
 
  Int2           j;
422
 
  Int2           num;
 
422
  Uint4          j;
 
423
  Uint4          num;
423
424
  ObjMgrPtr      omp;
424
425
  ObjMgrDataPtr  PNTR omdpp;
425
426
  OMUserDataPtr  omudp_tmp;
631
632
  }
632
633
}
633
634
 
 
635
static Boolean DlgStrandsMatch (Uint1 featstrand, Uint1 locstrand)
 
636
 
 
637
{
 
638
  if (featstrand == locstrand) return TRUE;
 
639
  if (locstrand == Seq_strand_unknown && featstrand != Seq_strand_minus) return TRUE;
 
640
  if (featstrand == Seq_strand_unknown && locstrand != Seq_strand_minus) return TRUE;
 
641
  if (featstrand == Seq_strand_both && locstrand != Seq_strand_minus) return TRUE;
 
642
  if (locstrand == Seq_strand_both) return TRUE;
 
643
  return FALSE;
 
644
}
 
645
 
634
646
static Boolean GeneUpdateFunc (GatherContextPtr gcp)
635
647
 
636
648
{
637
649
  GeneGatherPtr  ggp;
638
650
  ObjMgrTypePtr  omtp;
639
651
  SeqFeatPtr     sfp;
 
652
  Uint1          strand1, strand2;
640
653
  Char           thislabel [41];
641
654
 
642
655
  if (gcp == NULL) return TRUE;
659
672
      if (thislabel [0] != '\0') {
660
673
        ggp->idx++;
661
674
        if (ggp->idx == ggp->val) {
662
 
          UpdateGeneLocation (sfp, ggp->old_feature_location, ggp->slp, gcp->entityID);
663
 
          return FALSE;
 
675
          strand1 = SeqLocStrand (sfp->location);
 
676
          strand2 = SeqLocStrand (ggp->slp);
 
677
          if (DlgStrandsMatch (strand1, strand2)) {
 
678
            UpdateGeneLocation (sfp, ggp->old_feature_location, ggp->slp, gcp->entityID);
 
679
            return FALSE;
 
680
          }
664
681
        }
665
682
      }
666
683
    }
793
810
  GeneRefPtr      grp;
794
811
  ObjMgrTypePtr   omtp;
795
812
  SeqFeatPtr      sfp;
 
813
  Uint1           strand1, strand2;
796
814
  Char            thislabel [41];
797
815
 
798
816
  if (gcp == NULL) return TRUE;
847
865
        diff = SeqLocAinB (ggp->slp, sfp->location);
848
866
        if (diff >= 0) {
849
867
          if (diff < ggp->min) {
850
 
            ggp->min = diff;
851
 
            if (! ggp->xrefmatch) {
852
 
              ggp->val = ggp->idx;
 
868
            strand1 = SeqLocStrand (ggp->slp);
 
869
            strand2 = SeqLocStrand (sfp->location);
 
870
            if (DlgStrandsMatch (strand1, strand2)) {
 
871
              ggp->min = diff;
 
872
              if (! ggp->xrefmatch) {
 
873
                ggp->val = ggp->idx;
 
874
              }
853
875
            }
854
876
          }
855
877
        }
1283
1305
  }
1284
1306
}
1285
1307
 
 
1308
static UserObjectPtr CombineGOTermUserObjects (UserObjectPtr origuop, UserObjectPtr newuop)
 
1309
 
 
1310
{
 
1311
  ObjectIdPtr  oip;
 
1312
 
 
1313
  if (newuop == NULL) return origuop;
 
1314
  if (origuop == NULL) return newuop;
 
1315
 
 
1316
  oip = origuop->type;
 
1317
  if (oip != NULL && StringCmp (oip->str, "GeneOntology") == 0) return origuop;
 
1318
 
 
1319
  return CombineUserObjects (origuop, newuop);
 
1320
}
 
1321
 
1286
1322
typedef struct replacesdata {
1287
1323
  FeatureFormPtr  ffp;
1288
1324
  SeqFeatPtr      sfp;
1321
1357
        old->ext = NULL;
1322
1358
      }
1323
1359
      if (ffp->goTermUserObj != NULL) {
1324
 
        sfp->ext = CombineUserObjects (sfp->ext, ffp->goTermUserObj);
 
1360
        sfp->ext = CombineGOTermUserObjects (sfp->ext, ffp->goTermUserObj);
1325
1361
      }
1326
1362
      if (ffp->featid != NULL) {
1327
1363
        TextToFeatID (ffp->featid, &(sfp->id));
1816
1852
        InferenceDialogToGBQuals (ffp->inference, sfp, TRUE);
1817
1853
        sfp->ext = DialogToPointer (ffp->usrobjext);
1818
1854
        if (ffp->goTermUserObj != NULL) {
1819
 
          sfp->ext = CombineUserObjects (sfp->ext, ffp->goTermUserObj);
 
1855
          sfp->ext = CombineGOTermUserObjects (sfp->ext, ffp->goTermUserObj);
1820
1856
        }
1821
1857
        if (ffp->featid != NULL) {
1822
1858
          TextToFeatID (ffp->featid, &(sfp->id));
1840
1876
        InferenceDialogToGBQuals (ffp->inference, sfp, TRUE);
1841
1877
        sfp->ext = DialogToPointer (ffp->usrobjext);
1842
1878
        if (ffp->goTermUserObj != NULL) {
1843
 
          sfp->ext = CombineUserObjects (sfp->ext, ffp->goTermUserObj);
 
1879
          sfp->ext = CombineGOTermUserObjects (sfp->ext, ffp->goTermUserObj);
1844
1880
        }
1845
1881
        if (ffp->featid != NULL) {
1846
1882
          TextToFeatID (ffp->featid, &(sfp->id));
3310
3346
                              QualsDialogToGBQualPtr);
3311
3347
}
3312
3348
 
3313
 
static void CreateSeqAlignLabel (SeqAlignPtr salp, CharPtr buf, Int4 buf_size)
 
3349
extern void CreateSeqAlignLabel (SeqAlignPtr salp, CharPtr buf, Int4 buf_size)
3314
3350
{
3315
3351
  Int4     remaining_len, aln_pos, id_len;
3316
3352
  SeqIdPtr sip;
3336
3372
  }
3337
3373
  buf_ptr += 4;
3338
3374
  
3339
 
  for (aln_pos = 1; aln_pos <= salp->dim && remaining_len > 0; aln_pos++)
 
3375
  for (aln_pos = 1; aln_pos <= salp->dim && remaining_len > 2; aln_pos++)
3340
3376
  {
3341
3377
    sip = AlnMgr2GetNthSeqIdPtr(salp, aln_pos);
3342
3378
    SeqIdWrite (sip, buf_ptr, PRINTID_REPORT, remaining_len);
3344
3380
    remaining_len -= id_len;
3345
3381
    buf_ptr += id_len;
3346
3382
    /* put comma between IDs in list */
3347
 
    if (aln_pos < salp->dim && remaining_len > 0)
 
3383
    if (aln_pos < salp->dim && remaining_len > 2)
3348
3384
    {
3349
3385
      StringCat (buf_ptr, ",");
3350
3386
      remaining_len -= 1;
3392
3428
}
3393
3429
 
3394
3430
 
3395
 
static void GetAlignmentsInSeqEntryCallback (SeqAnnotPtr sap, Pointer userdata)
 
3431
extern void GetAlignmentsInSeqEntryCallback (SeqAnnotPtr sap, Pointer userdata)
3396
3432
{
3397
3433
  SeqAlignPtr PNTR salp_list;
3398
3434
  SeqAlignPtr salp, last_salp;
3534
3570
              bsp = BioseqLockById (sip);
3535
3571
              if (bsp != NULL) {
3536
3572
                AddToSipList (ipp, bsp);
 
3573
                BioseqUnlock (bsp);
3537
3574
              }
3538
 
              BioseqUnlockById (sip);
3539
3575
            }
3540
3576
          }
3541
3577
          slp = SeqLocFindNext (&vn, slp);
3647
3683
{
3648
3684
  SeqLocPtr           tmp_slp;
3649
3685
  SeqIdPtr            sip;
3650
 
  Int4                j;
 
3686
  Int4                j = 0;
3651
3687
  Boolean             found;
3652
3688
  ValNodePtr          missing_list = NULL, missing_vnp;
3653
3689
  Int4                new_count;
3687
3723
          bsp = BioseqFindCore (ipp->sip_list [j]);
3688
3724
          if (bsp == NULL) {
3689
3725
            bsp = BioseqLockById (ipp->sip_list [j]);
3690
 
            BioseqUnlockById (ipp->sip_list [j]);
 
3726
            BioseqUnlock (bsp);
3691
3727
          }
3692
3728
          if (bsp != NULL && SeqIdIn (sip, bsp->id))
3693
3729
          {
3710
3746
    new_sip_list = MemNew (sizeof (SeqIdPtr) * (size_t) new_count);
3711
3747
    new_alist = MemNew (sizeof (EnumFieldAssoc) * (size_t) new_count);
3712
3748
    new_lengths = MemNew (sizeof (Int4) * (size_t) new_count);
3713
 
    /* first one is blank, remainder are actual data */
3714
 
    for (j = 0; j < ipp->count + 1; j++)
3715
 
    {
3716
 
      new_sip_list [j] = ipp->sip_list [j];
3717
 
      ipp->sip_list [j] = NULL;
3718
 
      new_alist [j].name = ipp->alist [j].name;
3719
 
      ipp->alist [j].name = NULL;
3720
 
      new_alist [j].value = ipp->alist [j].value;
3721
 
      new_lengths [j] = ipp->lengths [j];
 
3749
    if (ipp->sip_list != NULL) {
 
3750
      /* first one is blank, remainder are actual data */
 
3751
      for (j = 0; j < ipp->count + 1; j++)
 
3752
      {
 
3753
        new_sip_list [j] = ipp->sip_list [j];
 
3754
        ipp->sip_list [j] = NULL;
 
3755
        new_alist [j].name = ipp->alist [j].name;
 
3756
        ipp->alist [j].name = NULL;
 
3757
        new_alist [j].value = ipp->alist [j].value;
 
3758
        new_lengths [j] = ipp->lengths [j];
 
3759
      }
3722
3760
    }
3723
3761
    
3724
3762
    missing_vnp = missing_list;
3731
3769
      bsp = BioseqFindCore (sip);
3732
3770
      if (bsp == NULL) {
3733
3771
        bsp = BioseqLockById (sip);
3734
 
        BioseqUnlockById (sip);
 
3772
        BioseqUnlock (bsp);
3735
3773
      }
3736
3774
      if (bsp != NULL)
3737
3775
      {
5095
5133
 Boolean         partial3, 
5096
5134
 Boolean         nullsBetween)
5097
5135
{
5098
 
  Int4             from, to, aln_from, aln_to, aln_row, aln_len;
 
5136
  Int4             from, to, aln_from, aln_to, aln_row, aln_len = 0;
5099
5137
  Boolean          fuzz_after;
5100
5138
  Boolean          fuzz_before;
5101
5139
  Int2             fuzz_from;
5498
5536
 
5499
5537
  ipp = (IntervalPagePtr) GetObjectExtra (d);
5500
5538
  if (ipp != NULL) {
5501
 
    if (mssg == VIB_MSG_INIT) {
5502
 
      SeqLocPtrToIntervalPage (d, NULL);
5503
 
    } else if (mssg == VIB_MSG_ENTER) {
5504
 
      SendMessageToDialog (ipp->ivals, VIB_MSG_ENTER);
5505
 
    } else if (mssg == VIB_MSG_RESET) {
5506
 
    }
5507
 
    else if (mssg == NUM_VIB_MSG + 1)
5508
 
    {
5509
 
      SetOnlySequenceAndStrand (ipp);
5510
 
    }
5511
 
    else if (mssg == NUM_VIB_MSG + 2)
5512
 
    {
5513
 
      ClearLocationPartialCheckboxes (ipp);
 
5539
    switch (mssg) {
 
5540
      case VIB_MSG_INIT:
 
5541
        SeqLocPtrToIntervalPage (d, NULL);
 
5542
        break;
 
5543
      case VIB_MSG_ENTER:
 
5544
        SendMessageToDialog (ipp->ivals, VIB_MSG_ENTER);
 
5545
        break;
 
5546
      case VIB_MSG_RESET:
 
5547
        /* do nothing */
 
5548
        break;
 
5549
      case NUM_VIB_MSG + 1:
 
5550
        SetOnlySequenceAndStrand (ipp);
 
5551
        break;
 
5552
      case NUM_VIB_MSG + 2:
 
5553
        ClearLocationPartialCheckboxes (ipp);
 
5554
        break;
 
5555
      case VIB_MSG_CUT :
 
5556
        StdCutTextProc (NULL);
 
5557
        break;
 
5558
      case VIB_MSG_COPY :
 
5559
        StdCopyTextProc (NULL);
 
5560
        break;
 
5561
      case VIB_MSG_PASTE :
 
5562
        StdPasteTextProc (NULL);
 
5563
        break;
 
5564
      case VIB_MSG_DELETE :
 
5565
        StdDeleteTextProc (NULL);
 
5566
        break;
5514
5567
    }
5515
5568
  }
5516
5569
}
5564
5617
  PrompT           p1;
5565
5618
  PrompT           p2;
5566
5619
  PrompT           p3;
 
5620
  PrompT           p_from, p_to;
5567
5621
  CharPtr          ptr;
5568
5622
  GrouP            q;
5569
5623
  GrouP            s;
5741
5795
            bsp = BioseqFindCore (sip);
5742
5796
            if (bsp == NULL) {
5743
5797
              bsp = BioseqLockById (sip);
5744
 
              BioseqUnlockById (sip);
 
5798
              BioseqUnlock (bsp);
5745
5799
            }
5746
5800
            if (bsp != NULL)
5747
5801
            {
5834
5888
    }
5835
5889
 
5836
5890
    f = HiddenGroup (m, 5, 0, NULL);
5837
 
    StaticPrompt (f, "From", 5 * stdCharWidth, 0, programFont, 'c');
5838
 
    StaticPrompt (f, "To", 5 * stdCharWidth, 0, programFont, 'c');
 
5891
    p_from = StaticPrompt (f, "From", 5 * stdCharWidth, 0, programFont, 'c');
 
5892
    p_to = StaticPrompt (f, "To", 5 * stdCharWidth, 0, programFont, 'c');
5839
5893
    p1 = NULL;
5840
5894
    p2 = NULL;
5841
5895
    p3 = NULL;
5869
5923
      num_cols ++;
5870
5924
    }
5871
5925
    
5872
 
    ipp->ivals = CreateTagListDialogExEx (f, rows, num_cols, spacing,
 
5926
    ipp->ivals = CreateTagListDialogEx3 (f, rows, num_cols, spacing,
5873
5927
                                        interval_types, interval_widths, ipp->alists,
5874
5928
                                        useBar, FALSE, NULL, NULL,
5875
 
                                        ipp->callbacks, callback_data, FALSE);
 
5929
                                        ipp->callbacks, callback_data, FALSE, TRUE);
5876
5930
 
5877
5931
    /* put back static interval_types values that may have been changed */
5878
5932
    interval_types [2] = TAGLIST_POPUP;
5885
5939
                  (HANDLE) q, (HANDLE) ipp->nullsBetween, NULL);
5886
5940
    tlp = (TagListPtr) GetObjectExtra (ipp->ivals);
5887
5941
    if (tlp != NULL) {
 
5942
      AlignObjects (ALIGN_JUSTIFY, (HANDLE) tlp->control [0], (HANDLE) p_from, NULL);
 
5943
      AlignObjects (ALIGN_JUSTIFY, (HANDLE) tlp->control [1], (HANDLE) p_to, NULL);
5888
5944
      if (ipp->strand_col > -1)
5889
5945
      {
5890
5946
        AlignObjects (ALIGN_JUSTIFY, (HANDLE) tlp->control [ipp->strand_col], (HANDLE) p1, NULL);
6610
6666
  }
6611
6667
}
6612
6668
 
 
6669
/* ValueList Editor */
 
6670
static CharPtr combine_strings (CharPtr s, CharPtr add)
 
6671
{
 
6672
  CharPtr total;
 
6673
  if (StringHasNoText (add))
 
6674
  {
 
6675
    return s;
 
6676
  }
 
6677
  if (StringHasNoText (s))
 
6678
  {
 
6679
    s = MemFree (s);
 
6680
    s = StringSave (add);
 
6681
  }
 
6682
  else
 
6683
  {
 
6684
    total = (CharPtr) MemNew (sizeof (Char) * (StringLen (s) + StringLen (add) + 2));
 
6685
    sprintf (total, "%s;%s", s, add);
 
6686
    s = MemFree (s);
 
6687
    s = total;
 
6688
  }
 
6689
  return s;
 
6690
}
 
6691
 
 
6692
 
 
6693
 
 
6694
typedef struct simpletextvalueedit {
 
6695
  DIALOG_MESSAGE_BLOCK
 
6696
  TaglistCallback change_notify;
 
6697
  Pointer         change_userdata;
 
6698
  TexT text;
 
6699
} SimpleTextValueEditData, PNTR SimpleTextValueEditPtr;
 
6700
 
 
6701
static void SimpleTextValueEditChange (TexT t)
 
6702
{
 
6703
  SimpleTextValueEditPtr dlg;
 
6704
  dlg = (SimpleTextValueEditPtr) GetObjectExtra (t);
 
6705
  if (dlg != NULL && dlg->change_notify != NULL)
 
6706
  {
 
6707
    (dlg->change_notify) (dlg->change_userdata);
 
6708
  }
 
6709
}
 
6710
 
 
6711
static void StringToSimpleTextValueEditDialog (DialoG d, Pointer data)
 
6712
{
 
6713
  SimpleTextValueEditPtr dlg;
 
6714
  dlg = (SimpleTextValueEditPtr) GetObjectExtra (d);
 
6715
 
 
6716
  if (dlg != NULL)
 
6717
  {
 
6718
    SetTitle (dlg->text, (CharPtr) data);
 
6719
    if (dlg->change_notify != NULL)
 
6720
    {
 
6721
      (dlg->change_notify) (dlg->change_userdata);
 
6722
    }
 
6723
  }
 
6724
}
 
6725
 
 
6726
 
 
6727
static Pointer SimpleTextValueEditDialogToString (DialoG d)
 
6728
{
 
6729
  SimpleTextValueEditPtr dlg;
 
6730
  dlg = (SimpleTextValueEditPtr) GetObjectExtra (d);
 
6731
 
 
6732
  if (dlg != NULL)
 
6733
  {
 
6734
    return SaveStringFromText (dlg->text);
 
6735
  }
 
6736
  else
 
6737
  {
 
6738
    return NULL;
 
6739
  }
 
6740
}
 
6741
 
 
6742
static DialoG SimpleTextValueEditDialog (GrouP h, Int2 width, ValueListParentPtr parent, TaglistCallback change_notify, Pointer change_userdata)
 
6743
{
 
6744
  SimpleTextValueEditPtr dlg;
 
6745
  GrouP           p;
 
6746
 
 
6747
  p = HiddenGroup (h, -1, 0, NULL);
 
6748
  SetGroupSpacing (p, 10, 10);
 
6749
  dlg = (SimpleTextValueEditPtr) MemNew (sizeof(SimpleTextValueEditData));
 
6750
 
 
6751
  SetObjectExtra (p, dlg, StdCleanupExtraProc);
 
6752
  dlg->dialog = (DialoG) p;
 
6753
  dlg->todialog = StringToSimpleTextValueEditDialog;
 
6754
  dlg->fromdialog = SimpleTextValueEditDialogToString;
 
6755
  dlg->testdialog = NULL;
 
6756
  dlg->dialogmessage = NULL;
 
6757
  dlg->change_notify = change_notify;
 
6758
  dlg->change_userdata = change_userdata;
 
6759
 
 
6760
  dlg->text = DialogText (p, "", width, SimpleTextValueEditChange);
 
6761
  SetObjectExtra (dlg->text, dlg, NULL);
 
6762
  return (DialoG) p;
 
6763
}
 
6764
 
 
6765
#define STRUCTURED_VALUE_EDIT_FIELDS \
 
6766
  DIALOG_MESSAGE_BLOCK \
 
6767
  TaglistCallback     change_notify; \
 
6768
  Pointer             change_userdata; \
 
6769
  GrouP               unparsable; \
 
6770
  TexT                text; \
 
6771
  ValueListParentPtr  parent; \
 
6772
  DialoG              dlg; \
 
6773
  ParseOK             parse_func;
 
6774
 
 
6775
typedef struct structuredvalueeditdlg {
 
6776
  STRUCTURED_VALUE_EDIT_FIELDS
 
6777
} StructuredValueEditDlgData, PNTR StructuredValueEditDlgPtr;
 
6778
 
 
6779
 
 
6780
static void CopyUnparsableToNote (ButtoN b)
 
6781
{
 
6782
  StructuredValueEditDlgPtr dlg;
 
6783
  CharPtr                   old_note, new_note;
 
6784
 
 
6785
  dlg = (StructuredValueEditDlgPtr) GetObjectExtra (b);
 
6786
 
 
6787
  if (dlg != NULL && dlg->parent != NULL && dlg->parent->note != NULL)
 
6788
  {
 
6789
    old_note = SaveStringFromText (dlg->parent->note);
 
6790
    new_note = SaveStringFromText (dlg->text);
 
6791
    old_note = combine_strings (old_note, new_note);
 
6792
    SetTitle (dlg->parent->note, old_note); 
 
6793
    new_note = MemFree (new_note);
 
6794
    old_note = MemFree (old_note);
 
6795
    SetTitle (dlg->text, "");
 
6796
    Hide (dlg->unparsable);
 
6797
    if (dlg != NULL && dlg->change_notify != NULL)
 
6798
    {
 
6799
      (dlg->change_notify) (dlg->change_userdata);
 
6800
    }
 
6801
  }
 
6802
}
 
6803
 
 
6804
 
 
6805
static void EraseUnparsable (ButtoN b)
 
6806
{
 
6807
  StructuredValueEditDlgPtr dlg;
 
6808
 
 
6809
  dlg = (StructuredValueEditDlgPtr) GetObjectExtra (b);
 
6810
 
 
6811
  if (dlg != NULL)
 
6812
  {
 
6813
    SetTitle (dlg->text, "");
 
6814
    Hide (dlg->unparsable);
 
6815
    if (dlg != NULL && dlg->change_notify != NULL)
 
6816
    {
 
6817
      (dlg->change_notify) (dlg->change_userdata);
 
6818
    }
 
6819
  }
 
6820
}
 
6821
 
 
6822
 
 
6823
static void StringToStructuredValueEditDialog (DialoG d, Pointer data)
 
6824
{
 
6825
  StructuredValueEditDlgPtr dlg;
 
6826
  CharPtr                   txt;
 
6827
 
 
6828
  dlg = (StructuredValueEditDlgPtr) GetObjectExtra (d);
 
6829
 
 
6830
  txt = (CharPtr) data;
 
6831
 
 
6832
  if (dlg != NULL)
 
6833
  {
 
6834
    if (StringHasNoText (txt) || (dlg->parse_func != NULL && (dlg->parse_func) (txt)))
 
6835
    {
 
6836
      PointerToDialog (dlg->dlg, txt);
 
6837
      SetTitle (dlg->text, "");
 
6838
      Hide (dlg->unparsable);
 
6839
    }
 
6840
    else
 
6841
    {
 
6842
      SetTitle (dlg->text, (CharPtr) data);
 
6843
      Show (dlg->unparsable);
 
6844
    }
 
6845
    if (dlg->change_notify != NULL)
 
6846
    {
 
6847
      (dlg->change_notify) (dlg->change_userdata);
 
6848
    }
 
6849
  }
 
6850
}
 
6851
 
 
6852
 
 
6853
static Pointer StructuredValueEditDialogToString (DialoG d)
 
6854
{
 
6855
  StructuredValueEditDlgPtr dlg;
 
6856
  CharPtr                   txt = NULL, tmp;
 
6857
 
 
6858
  dlg = (StructuredValueEditDlgPtr) GetObjectExtra (d);
 
6859
 
 
6860
  if (dlg != NULL)
 
6861
  {
 
6862
    if (dlg->dlg == NULL)
 
6863
    {
 
6864
      txt = StringSave ("");
 
6865
    }
 
6866
    else
 
6867
    {
 
6868
      txt = DialogToPointer (dlg->dlg);
 
6869
    }
 
6870
    
 
6871
    if (!TextHasNoText (dlg->text))
 
6872
    {
 
6873
      tmp = SaveStringFromText (dlg->text);
 
6874
      txt = combine_strings (txt, tmp);
 
6875
      tmp = MemFree (tmp);
 
6876
    }
 
6877
  }
 
6878
  return txt;
 
6879
 
 
6880
}
 
6881
 
 
6882
 
 
6883
static void StructuredValueEditChange (TexT t)
 
6884
{
 
6885
  StructuredValueEditDlgPtr dlg;
 
6886
  CharPtr                    txt, tmp;
 
6887
 
 
6888
  dlg = (StructuredValueEditDlgPtr) GetObjectExtra (t);
 
6889
 
 
6890
  if (TextHasNoText (dlg->text))
 
6891
  {
 
6892
    Hide (dlg->unparsable);
 
6893
  }
 
6894
  else if (dlg->dlg != NULL)
 
6895
  {
 
6896
    txt = SaveStringFromText(dlg->text);
 
6897
    tmp = DialogToPointer (dlg->dlg);
 
6898
    if (StringHasNoText (tmp) && dlg->parse_func != NULL && (dlg->parse_func)(txt))
 
6899
    {
 
6900
      PointerToDialog (dlg->dlg, txt);
 
6901
      SetTitle (dlg->text, "");
 
6902
      Hide (dlg->unparsable);
 
6903
    }
 
6904
    txt = MemFree (txt);
 
6905
    tmp = MemFree (tmp);
 
6906
  }
 
6907
 
 
6908
  if (dlg != NULL && dlg->change_notify != NULL)
 
6909
  {
 
6910
    (dlg->change_notify) (dlg->change_userdata);
 
6911
  }
 
6912
}
 
6913
 
 
6914
 
 
6915
 
 
6916
typedef struct truefalsevalueedit {
 
6917
  STRUCTURED_VALUE_EDIT_FIELDS
 
6918
} TrueFalseValueEditData, PNTR TrueFalseValueEditPtr;
 
6919
 
 
6920
static DialoG TrueFalseValueEditDialog (GrouP h, Int2 width, ValueListParentPtr parent, TaglistCallback change_notify, Pointer change_userdata)
 
6921
{
 
6922
  TrueFalseValueEditPtr dlg;
 
6923
  GrouP           p;
 
6924
  ButtoN          b;
 
6925
 
 
6926
  p = HiddenGroup (h, 2, 0, NULL);
 
6927
  SetGroupSpacing (p, 10, 10);
 
6928
  dlg = (TrueFalseValueEditPtr) MemNew (sizeof(TrueFalseValueEditData));
 
6929
 
 
6930
  SetObjectExtra (p, dlg, StdCleanupExtraProc);
 
6931
  dlg->dialog = (DialoG) p;
 
6932
  dlg->todialog = StringToStructuredValueEditDialog;
 
6933
  dlg->fromdialog = StructuredValueEditDialogToString;
 
6934
  dlg->testdialog = NULL;
 
6935
  dlg->dialogmessage = NULL;
 
6936
  dlg->change_notify = change_notify;
 
6937
  dlg->change_userdata = change_userdata;
 
6938
  dlg->parent = parent;
 
6939
 
 
6940
  StaticPrompt (p, "TRUE", 0, 0, programFont, 'c');
 
6941
 
 
6942
  dlg->unparsable = HiddenGroup (p, 3, 0, NULL);
 
6943
  SetGroupSpacing (dlg->unparsable, 10, 10);
 
6944
  dlg->text = DialogText (dlg->unparsable, "", width - 15, StructuredValueEditChange);
 
6945
  SetObjectExtra (dlg->text, dlg, NULL);
 
6946
 
 
6947
  b = PushButton (dlg->unparsable, "Copy to Note", CopyUnparsableToNote);
 
6948
  SetObjectExtra (b, dlg, NULL);
 
6949
 
 
6950
  b = PushButton (dlg->unparsable, "Erase", EraseUnparsable);
 
6951
  SetObjectExtra (b, dlg, NULL);
 
6952
 
 
6953
  Hide (dlg->unparsable);
 
6954
 
 
6955
  return (DialoG) p;
 
6956
}
 
6957
 
 
6958
 
 
6959
typedef struct latlondlg {
 
6960
  DIALOG_MESSAGE_BLOCK
 
6961
 
 
6962
  PopuP dir_ns;
 
6963
  PopuP dir_ew;
 
6964
  TexT  deg_ns;
 
6965
  TexT  deg_ew;
 
6966
 
 
6967
  TaglistCallback change_notify;
 
6968
  Pointer change_userdata;
 
6969
 
 
6970
} LatLonDlgData, PNTR LatLonDlgPtr;
 
6971
 
 
6972
 
 
6973
static void ResetLatLonDlg (LatLonDlgPtr dlg)
 
6974
{
 
6975
  if (dlg == NULL) return;
 
6976
 
 
6977
  SetTitle (dlg->deg_ns, "");
 
6978
  SetValue (dlg->dir_ns, 1);
 
6979
  SetTitle (dlg->deg_ew, "");
 
6980
  SetValue (dlg->dir_ew, 1);
 
6981
}
 
6982
 
 
6983
 
 
6984
static void StringToLatLonDlg (DialoG d, Pointer data)
 
6985
{
 
6986
  LatLonDlgPtr dlg;
 
6987
  CharPtr      str, ns, ew, tmp;
 
6988
  Int4         len;
 
6989
 
 
6990
  dlg = (LatLonDlgPtr) GetObjectExtra (d);
 
6991
  if (dlg == NULL) return;
 
6992
  
 
6993
  str = (CharPtr) data;
 
6994
  if (str == NULL)
 
6995
  {
 
6996
    ResetLatLonDlg (dlg);
 
6997
    return;
 
6998
  }
 
6999
 
 
7000
  ew = str + StringLen (str) - 1;
 
7001
  if (*ew != 'E' && *ew != 'W')
 
7002
  {
 
7003
    ResetLatLonDlg (dlg);
 
7004
    return;
 
7005
  }
 
7006
  
 
7007
  ns = StringChr (str, 'N');
 
7008
  if (ns == NULL)
 
7009
  {
 
7010
    ns = StringChr (str, 'S');
 
7011
  }
 
7012
  if (ns == NULL)
 
7013
  {
 
7014
    ResetLatLonDlg (dlg);
 
7015
    return;
 
7016
  }
 
7017
 
 
7018
  len = ns - str + 1;
 
7019
  tmp = (CharPtr) MemNew (sizeof (Char) * len);
 
7020
  StringNCpy (tmp, str, len - 1);
 
7021
  tmp [len - 1] = 0;
 
7022
  SetTitle (dlg->deg_ns, tmp);
 
7023
  tmp = MemFree (tmp);
 
7024
  SetValue (dlg->dir_ns, *ns == 'N' ? 1 : 2);
 
7025
  
 
7026
  len = ew - ns;
 
7027
  tmp = (CharPtr) MemNew (sizeof (Char) * len);
 
7028
  StringNCpy (tmp, ns + 1, len - 1);
 
7029
  tmp [len - 1] = 0;
 
7030
  SetTitle (dlg->deg_ew, tmp);
 
7031
  tmp = MemFree (tmp);
 
7032
  SetValue (dlg->dir_ew, *ew == 'E' ? 1 : 2);
 
7033
  
 
7034
}
 
7035
 
 
7036
 
 
7037
static Pointer LatLonDlgToString (DialoG d)
 
7038
{
 
7039
  LatLonDlgPtr dlg;
 
7040
  CharPtr      str, ns, ew;
 
7041
  Int4         len;
 
7042
 
 
7043
  dlg = (LatLonDlgPtr) GetObjectExtra (d);
 
7044
  if (dlg == NULL) return NULL;
 
7045
 
 
7046
  if (TextHasNoText (dlg->deg_ns) && TextHasNoText (dlg->deg_ew))
 
7047
  {
 
7048
    return NULL;
 
7049
  }  
 
7050
 
 
7051
  ns = SaveStringFromText (dlg->deg_ns);
 
7052
  ew = SaveStringFromText (dlg->deg_ew);
 
7053
  len = StringLen (ns) + StringLen (ew) + 6;
 
7054
  str = (CharPtr) MemNew (sizeof(Char) * len);
 
7055
  sprintf (str, "%s %c %s %c", 
 
7056
           ns == NULL ? "" : ns,
 
7057
           GetValue (dlg->dir_ns) == 1 ? 'N' : 'S',
 
7058
           ew == NULL ? "" : ew,
 
7059
           GetValue (dlg->dir_ew) == 1 ? 'E' : 'W');
 
7060
  ns = MemFree (ns);
 
7061
  ew = MemFree (ew);
 
7062
  return str;
 
7063
}
 
7064
 
 
7065
static void LatLonTextChange (TexT t)
 
7066
{
 
7067
  LatLonDlgPtr dlg;
 
7068
 
 
7069
  dlg = (LatLonDlgPtr) GetObjectExtra (t);
 
7070
  if (dlg == NULL) return;
 
7071
 
 
7072
 
 
7073
  if (dlg->change_notify != NULL)
 
7074
  {
 
7075
    (dlg->change_notify) (dlg->change_userdata);
 
7076
  }
 
7077
}
 
7078
 
 
7079
 
 
7080
static void LatLonPopupChange (PopuP p)
 
7081
{
 
7082
  LatLonDlgPtr dlg;
 
7083
 
 
7084
  dlg = (LatLonDlgPtr) GetObjectExtra (p);
 
7085
  if (dlg == NULL) return;
 
7086
 
 
7087
 
 
7088
  if (dlg->change_notify != NULL)
 
7089
  {
 
7090
    (dlg->change_notify) (dlg->change_userdata);
 
7091
  }
 
7092
}
 
7093
 
 
7094
 
 
7095
static DialoG LatLonDialog (GrouP h, TaglistCallback change_notify, Pointer change_userdata)
 
7096
{
 
7097
  LatLonDlgPtr dlg;
 
7098
  GrouP        p;
 
7099
 
 
7100
  p = HiddenGroup (h, 4, 0, NULL);
 
7101
  SetGroupSpacing (p, 10, 10);
 
7102
  dlg = (LatLonDlgPtr) MemNew (sizeof(LatLonDlgData));
 
7103
 
 
7104
  SetObjectExtra (p, dlg, StdCleanupExtraProc);
 
7105
  dlg->dialog = (DialoG) p;
 
7106
  dlg->todialog = StringToLatLonDlg;
 
7107
  dlg->fromdialog = LatLonDlgToString;
 
7108
  dlg->testdialog = NULL;
 
7109
  dlg->dialogmessage = NULL;
 
7110
  dlg->change_notify = change_notify;
 
7111
  dlg->change_userdata = change_userdata;
 
7112
 
 
7113
  dlg->deg_ns = DialogText (p, "", 3, LatLonTextChange);
 
7114
  SetObjectExtra (dlg->deg_ns, dlg, NULL);
 
7115
  dlg->dir_ns = PopupList (p, TRUE, LatLonPopupChange);
 
7116
  SetObjectExtra (dlg->dir_ns, dlg, NULL);
 
7117
  PopupItem (dlg->dir_ns, "N");
 
7118
  PopupItem (dlg->dir_ns, "S");
 
7119
  SetValue (dlg->dir_ns, 1);
 
7120
 
 
7121
  dlg->deg_ew = DialogText (p, "", 3, LatLonTextChange);
 
7122
  SetObjectExtra (dlg->deg_ew, dlg, NULL);
 
7123
  dlg->dir_ew = PopupList (p, TRUE, LatLonPopupChange);
 
7124
  SetObjectExtra (dlg->dir_ew, dlg, NULL);
 
7125
  PopupItem (dlg->dir_ew, "E");
 
7126
  PopupItem (dlg->dir_ew, "W");
 
7127
 
 
7128
  SetValue (dlg->dir_ew, 1);
 
7129
  
 
7130
  return (DialoG) p;
 
7131
}
 
7132
 
 
7133
 
 
7134
static Boolean ParseLatLonOk (CharPtr str)
 
7135
{
 
7136
  Boolean rval = FALSE;
 
7137
  CharPtr ns, ew, cp;
 
7138
 
 
7139
  if (StringHasNoText (str))
 
7140
  {
 
7141
    return TRUE;
 
7142
  }
 
7143
  ew = str + StringLen (str) - 1;
 
7144
  if (*ew != 'E' && *ew != 'W')
 
7145
  {
 
7146
    return FALSE;
 
7147
  }
 
7148
  ns = str;
 
7149
  while (ns < ew && !isalpha (*ns))
 
7150
  {
 
7151
    ns++;
 
7152
  }
 
7153
  if (*ns != 'N' && *ns != 'S')
 
7154
  {
 
7155
    return FALSE;
 
7156
  }
 
7157
 
 
7158
  cp = ns + 1;
 
7159
  while (cp < ew)
 
7160
  {
 
7161
    if (isalpha (*cp))
 
7162
    {
 
7163
      return FALSE;
 
7164
    }
 
7165
    cp++;
 
7166
  }
 
7167
  return TRUE;
 
7168
}
 
7169
 
 
7170
 
 
7171
static DialoG ValueListLatLonDialog (GrouP h, Int2 width, ValueListParentPtr parent, TaglistCallback change_notify, Pointer change_userdata)
 
7172
{
 
7173
  StructuredValueEditDlgPtr dlg;
 
7174
  GrouP           p;
 
7175
  ButtoN          b;
 
7176
 
 
7177
 
 
7178
  p = HiddenGroup (h, 2, 0, NULL);
 
7179
  SetGroupSpacing (p, 10, 10);
 
7180
  dlg = (StructuredValueEditDlgPtr) MemNew (sizeof(StructuredValueEditDlgData));
 
7181
 
 
7182
  SetObjectExtra (p, dlg, StdCleanupExtraProc);
 
7183
  dlg->dialog = (DialoG) p;
 
7184
  dlg->todialog = StringToStructuredValueEditDialog;
 
7185
  dlg->fromdialog = StructuredValueEditDialogToString;
 
7186
  dlg->testdialog = NULL;
 
7187
  dlg->dialogmessage = NULL;
 
7188
  dlg->change_notify = change_notify;
 
7189
  dlg->change_userdata = change_userdata;
 
7190
  dlg->parent = parent;
 
7191
 
 
7192
  dlg->dlg = LatLonDialog (p, change_notify, change_userdata);
 
7193
  dlg->parse_func = ParseLatLonOk;
 
7194
  
 
7195
  dlg->unparsable = HiddenGroup (p, 3, 0, NULL);
 
7196
  SetGroupSpacing (dlg->unparsable, 10, 10);
 
7197
  dlg->text = DialogText (dlg->unparsable, "", width - 15, StructuredValueEditChange);
 
7198
  SetObjectExtra (dlg->text, dlg, NULL);
 
7199
 
 
7200
  b = PushButton (dlg->unparsable, "Copy to Note", CopyUnparsableToNote);
 
7201
  SetObjectExtra (b, dlg, NULL);
 
7202
 
 
7203
  b = PushButton (dlg->unparsable, "Erase", EraseUnparsable);
 
7204
  SetObjectExtra (b, dlg, NULL);
 
7205
 
 
7206
  Hide (dlg->unparsable);
 
7207
 
 
7208
  return (DialoG) p;
 
7209
}
 
7210
 
 
7211
 
 
7212
typedef struct specimenvoucherdlg {
 
7213
  DIALOG_MESSAGE_BLOCK
 
7214
 
 
7215
  TexT  institution_code;
 
7216
  TexT  collection_code;
 
7217
  TexT  free_text;
 
7218
 
 
7219
  TaglistCallback change_notify;
 
7220
  Pointer change_userdata;
 
7221
 
 
7222
} SpecimenVoucherDlgData, PNTR SpecimenVoucherDlgPtr;
 
7223
 
 
7224
 
 
7225
static void ResetSpecimenVoucherDlg (SpecimenVoucherDlgPtr dlg)
 
7226
{
 
7227
  if (dlg == NULL) return;
 
7228
 
 
7229
  SetTitle (dlg->institution_code, "");
 
7230
  SetTitle (dlg->collection_code, "");
 
7231
  SetTitle (dlg->free_text, "");
 
7232
}
 
7233
 
 
7234
 
 
7235
static void StringToSpecimenVoucherDlg (DialoG d, Pointer data)
 
7236
{
 
7237
  SpecimenVoucherDlgPtr dlg;
 
7238
  CharPtr      str, ptr, cp;
 
7239
 
 
7240
  dlg = (SpecimenVoucherDlgPtr) GetObjectExtra (d);
 
7241
  if (dlg == NULL) return;
 
7242
  
 
7243
  str = (CharPtr) data;
 
7244
  if (str == NULL)
 
7245
  {
 
7246
    ResetSpecimenVoucherDlg (dlg);
 
7247
    return;
 
7248
  }
 
7249
 
 
7250
  /* make copy so we don't worry about changing data */
 
7251
  str = StringSave (str);
 
7252
 
 
7253
  cp = StringChr (str, ':');
 
7254
  if (cp == NULL)
 
7255
  {
 
7256
    SetTitle (dlg->free_text, str);
 
7257
  }
 
7258
  else 
 
7259
  {
 
7260
    *cp = 0;
 
7261
    SetTitle (dlg->institution_code, str);
 
7262
    ptr = cp + 1;
 
7263
    cp = StringChr (ptr, ':');
 
7264
    if (cp == NULL) 
 
7265
    {
 
7266
      SetTitle (dlg->free_text, ptr);
 
7267
    }
 
7268
    else 
 
7269
    {
 
7270
      *cp = 0;
 
7271
      SetTitle (dlg->collection_code, ptr);
 
7272
      SetTitle (dlg->free_text, cp + 1);
 
7273
    }
 
7274
  }
 
7275
  str = MemFree (str);
 
7276
}
 
7277
 
 
7278
 
 
7279
static Pointer SpecimenVoucherDlgToString (DialoG d)
 
7280
{
 
7281
  SpecimenVoucherDlgPtr dlg;
 
7282
  CharPtr      str;
 
7283
  Int4         len;
 
7284
  CharPtr      inst, coll, free_text;
 
7285
 
 
7286
  dlg = (SpecimenVoucherDlgPtr) GetObjectExtra (d);
 
7287
  if (dlg == NULL) return NULL;
 
7288
 
 
7289
  if (TextHasNoText (dlg->institution_code) && TextHasNoText (dlg->collection_code) && TextHasNoText (dlg->free_text))
 
7290
  {
 
7291
    return NULL;
 
7292
  }  
 
7293
 
 
7294
  inst = SaveStringFromText (dlg->institution_code);
 
7295
  coll = SaveStringFromText (dlg->collection_code);
 
7296
  free_text = SaveStringFromText (dlg->free_text);
 
7297
 
 
7298
  len = StringLen (inst) + StringLen (coll) + StringLen (free_text) + 3;
 
7299
  str = (CharPtr) MemNew (sizeof(Char) * len);
 
7300
  if (StringHasNoText (inst) && StringHasNoText (coll))
 
7301
  {
 
7302
    sprintf (str, "%s", free_text);
 
7303
  }
 
7304
  else if (StringHasNoText (coll))
 
7305
  {
 
7306
    sprintf (str, "%s:%s", inst, free_text == NULL ? "" : free_text);
 
7307
  }
 
7308
  else
 
7309
  {
 
7310
    sprintf (str, "%s:%s:%s", inst == NULL ? "" : inst,
 
7311
                              coll == NULL ? "" : coll,
 
7312
                              free_text == NULL ? "" : free_text);
 
7313
  }
 
7314
  inst = MemFree (inst);
 
7315
  coll = MemFree (coll);
 
7316
  free_text = MemFree (free_text);
 
7317
  return str;
 
7318
}
 
7319
 
 
7320
static void SpecimenVoucherTextChange (TexT t)
 
7321
{
 
7322
  SpecimenVoucherDlgPtr dlg;
 
7323
 
 
7324
  dlg = (SpecimenVoucherDlgPtr) GetObjectExtra (t);
 
7325
  if (dlg == NULL) return;
 
7326
 
 
7327
 
 
7328
  if (dlg->change_notify != NULL)
 
7329
  {
 
7330
    (dlg->change_notify) (dlg->change_userdata);
 
7331
  }
 
7332
}
 
7333
 
 
7334
 
 
7335
static DialoG SpecimenVoucherDialog (GrouP h, Int2 width, ValueListParentPtr parent, TaglistCallback change_notify, Pointer change_userdata)
 
7336
{
 
7337
  SpecimenVoucherDlgPtr dlg;
 
7338
  GrouP        p;
 
7339
 
 
7340
  p = HiddenGroup (h, 6, 0, NULL);
 
7341
  SetGroupSpacing (p, 10, 10);
 
7342
  dlg = (SpecimenVoucherDlgPtr) MemNew (sizeof(SpecimenVoucherDlgData));
 
7343
 
 
7344
  SetObjectExtra (p, dlg, StdCleanupExtraProc);
 
7345
  dlg->dialog = (DialoG) p;
 
7346
  dlg->todialog = StringToSpecimenVoucherDlg;
 
7347
  dlg->fromdialog = SpecimenVoucherDlgToString;
 
7348
  dlg->testdialog = NULL;
 
7349
  dlg->dialogmessage = NULL;
 
7350
  dlg->change_notify = change_notify;
 
7351
  dlg->change_userdata = change_userdata;
 
7352
 
 
7353
  StaticPrompt (p, "Inst", 0, 0, programFont, 'r');
 
7354
  dlg->institution_code = DialogText (p, "", 4, SpecimenVoucherTextChange);
 
7355
  SetObjectExtra (dlg->institution_code, dlg, NULL);
 
7356
  StaticPrompt (p, "Coll", 0, 0, programFont, 'r');
 
7357
  dlg->collection_code = DialogText (p, "", 4, SpecimenVoucherTextChange);
 
7358
  SetObjectExtra (dlg->collection_code, dlg, NULL);
 
7359
 
 
7360
  StaticPrompt (p, "SpecID/Text", 0, 0, programFont, 'r');
 
7361
  dlg->free_text = DialogText (p, "", width - 8, SpecimenVoucherTextChange);
 
7362
  SetObjectExtra (dlg->free_text, dlg, NULL);
 
7363
  
 
7364
  return (DialoG) p;
 
7365
}
 
7366
 
 
7367
 
 
7368
static Boolean ParseSpecimenVoucherOk (CharPtr str)
 
7369
{
 
7370
  return TRUE;
 
7371
}
 
7372
 
 
7373
 
 
7374
typedef DialoG (*MakeValueEditDialogFunc) PROTO ((GrouP, Int2, ValueListParentPtr, TaglistCallback, Pointer));
 
7375
 
 
7376
static MakeValueEditDialogFunc value_edit_dialog_list[] = {
 
7377
  SimpleTextValueEditDialog,
 
7378
  TrueFalseValueEditDialog,
 
7379
  ValueListLatLonDialog,
 
7380
  SpecimenVoucherDialog
 
7381
};
 
7382
 
 
7383
 
 
7384
extern NameValuePairPtr NameValuePairFree (NameValuePairPtr nvp)
 
7385
{
 
7386
  if (nvp != NULL)
 
7387
  {
 
7388
    nvp->name_vnp = ValNodeFreeData (nvp->name_vnp);
 
7389
    nvp->value = MemFree (nvp->value);
 
7390
    nvp = MemFree (nvp);
 
7391
  }
 
7392
  return nvp;
 
7393
}
 
7394
 
 
7395
 
 
7396
extern NameValuePairPtr NameValuePairCopy (NameValuePairPtr nvp)
 
7397
{
 
7398
  NameValuePairPtr cpy = NULL;
 
7399
 
 
7400
  if (nvp != NULL)
 
7401
  {
 
7402
    cpy = (NameValuePairPtr) MemNew (sizeof (NameValuePairData));
 
7403
    if (nvp->name_vnp != NULL)
 
7404
    {
 
7405
      cpy->name_vnp = ValNodeNew (NULL);
 
7406
      cpy->name_vnp->choice = nvp->name_vnp->choice;
 
7407
      cpy->name_vnp->data.ptrvalue = StringSave (nvp->name_vnp->data.ptrvalue);
 
7408
    }
 
7409
    cpy->value = StringSave (nvp->value);
 
7410
  }
 
7411
  return cpy;
 
7412
}
 
7413
 
 
7414
 
 
7415
extern ValNodePtr NameValuePairListFree (ValNodePtr vnp)
 
7416
{
 
7417
  ValNodePtr vnp_next;
 
7418
 
 
7419
  while (vnp != NULL)
 
7420
  {
 
7421
    vnp->data.ptrvalue = NameValuePairFree (vnp->data.ptrvalue);
 
7422
    vnp_next = vnp->next;
 
7423
    vnp->next= NULL;
 
7424
    vnp = ValNodeFree (vnp);
 
7425
    vnp = vnp_next;
 
7426
  }
 
7427
  return vnp;
 
7428
}
 
7429
 
 
7430
 
 
7431
typedef struct valuelistrowdialog {
 
7432
  DIALOG_MESSAGE_BLOCK
 
7433
 
 
7434
  TaglistCallback change_notify;
 
7435
  Pointer         change_userdata;
 
7436
  DialoG          parent_dlg;
 
7437
  DialoG          name_dlg;
 
7438
  DialoG          editors[eNumValueEditors];
 
7439
  Int4            current_editor;
 
7440
} ValueListRowDialogData, PNTR ValueListRowDialogPtr;
 
7441
 
 
7442
 
 
7443
static void ChangeValueListRowName (Pointer data)
 
7444
{
 
7445
  ValueListRowDialogPtr dlg;
 
7446
  ValNodePtr            vnp;
 
7447
  Int4                  i;
 
7448
  CharPtr               value = NULL;
 
7449
 
 
7450
  dlg = (ValueListRowDialogPtr) data;
 
7451
  if (dlg == NULL) return;
 
7452
 
 
7453
  if (dlg->current_editor > -1)
 
7454
  {
 
7455
    value = (CharPtr) DialogToPointer (dlg->editors[dlg->current_editor]);
 
7456
  }
 
7457
  for (i = 0; i < eNumValueEditors; i++)
 
7458
  {
 
7459
    Hide (dlg->editors[i]);
 
7460
  }
 
7461
  vnp = (ValNodePtr) DialogToPointer (dlg->name_dlg);
 
7462
  if (vnp != NULL && vnp->choice > 0)
 
7463
  {
 
7464
    dlg->current_editor = vnp->choice - 1;
 
7465
    Show (dlg->editors[dlg->current_editor]);
 
7466
    PointerToDialog (dlg->editors[dlg->current_editor], value);
 
7467
    vnp = ValNodeFree (vnp);
 
7468
  } else {
 
7469
    dlg->current_editor = -1;
 
7470
  }
 
7471
  value = MemFree (value);
 
7472
 
 
7473
  if (dlg->change_notify != NULL)
 
7474
  {
 
7475
    (dlg->change_notify) (dlg->change_userdata);
 
7476
  }
 
7477
}
 
7478
 
 
7479
 
 
7480
static void NameValuePairToDialog (DialoG d, Pointer data)
 
7481
{
 
7482
  ValueListRowDialogPtr dlg;
 
7483
  NameValuePairPtr      nvp;
 
7484
  ValNode               vn;
 
7485
  Int4                  i;
 
7486
 
 
7487
  dlg = (ValueListRowDialogPtr) GetObjectExtra (d);
 
7488
  nvp = (NameValuePairPtr) data;
 
7489
 
 
7490
  if (dlg == NULL) return;
 
7491
  if (nvp == NULL)
 
7492
  {
 
7493
    vn.next = NULL;
 
7494
    vn.choice = 0;
 
7495
    vn.data.ptrvalue = " ";
 
7496
    PointerToDialog (dlg->name_dlg, &vn);
 
7497
    for (i = 0; i < eNumValueEditors; i++)
 
7498
    {
 
7499
      PointerToDialog (dlg->editors[i], NULL);
 
7500
    }
 
7501
    ChangeValueListRowName (dlg);
 
7502
  }
 
7503
  else
 
7504
  {
 
7505
    PointerToDialog (dlg->name_dlg, nvp->name_vnp);
 
7506
    ChangeValueListRowName (dlg);
 
7507
    if (dlg->current_editor > -1)
 
7508
    {
 
7509
      PointerToDialog (dlg->editors[dlg->current_editor], nvp->value);
 
7510
      if (dlg->change_notify != NULL)
 
7511
      {
 
7512
        (dlg->change_notify) (dlg->change_userdata);
 
7513
      }
 
7514
    }
 
7515
  }    
 
7516
}
 
7517
 
 
7518
 
 
7519
static Pointer DialogToNameValuePair (DialoG d)
 
7520
{
 
7521
  ValueListRowDialogPtr dlg;
 
7522
  NameValuePairPtr      nvp;
 
7523
  ValNodePtr            name_vnp;
 
7524
 
 
7525
  dlg = (ValueListRowDialogPtr) GetObjectExtra (d);
 
7526
  if (dlg == NULL || dlg->current_editor < 0) return NULL;
 
7527
 
 
7528
  name_vnp = DialogToPointer (dlg->name_dlg);
 
7529
  if (name_vnp == NULL) return NULL;
 
7530
 
 
7531
  nvp = (NameValuePairPtr) MemNew (sizeof (NameValuePairData));
 
7532
  nvp->name_vnp = name_vnp;
 
7533
  nvp->value = DialogToPointer (dlg->editors[dlg->current_editor]);
 
7534
  return nvp;
 
7535
}
 
7536
 
 
7537
 
 
7538
static ValNodePtr CopyChoiceList (ValNodePtr orig)
 
7539
{
 
7540
  ValNodePtr vnp, cpy = NULL, prev = NULL;
 
7541
 
 
7542
  while (orig != NULL)
 
7543
  {
 
7544
    vnp = ValNodeNew (NULL);
 
7545
    vnp->choice = orig->choice;
 
7546
    vnp->data.ptrvalue = StringSave (orig->data.ptrvalue);
 
7547
    if (prev == NULL)
 
7548
    {
 
7549
      cpy = vnp;
 
7550
    }
 
7551
    else
 
7552
    {
 
7553
      prev->next = vnp;
 
7554
    }
 
7555
    prev = vnp;
 
7556
    orig = orig->next;
 
7557
  }
 
7558
  return cpy;
 
7559
}
 
7560
 
 
7561
static ValNodePtr TestValueListRowDialog (DialoG d)
 
7562
{
 
7563
  ValueListRowDialogPtr dlg;
 
7564
  ValNodePtr            name_vnp, err_list = NULL;
 
7565
  CharPtr               val, err_str;
 
7566
  CharPtr               err_fmt = "No modifier type selected for data %s";
 
7567
 
 
7568
  dlg = (ValueListRowDialogPtr) GetObjectExtra (d);
 
7569
  if (dlg == NULL || dlg->current_editor < 0) return NULL;
 
7570
 
 
7571
  val = DialogToPointer (dlg->editors[dlg->current_editor]);
 
7572
  if (!StringHasNoText (val))
 
7573
  {
 
7574
    name_vnp = DialogToPointer (dlg->name_dlg);
 
7575
    if (name_vnp == NULL || name_vnp->choice == 0)
 
7576
    {
 
7577
      err_str = (CharPtr) MemNew (sizeof (Char) * (StringLen (err_fmt) + StringLen (val)));
 
7578
      sprintf (err_str, err_fmt, val);
 
7579
      err_list = ValNodeNew(NULL);
 
7580
      err_list->choice = 0;     
 
7581
      err_list->data.ptrvalue = err_str;
 
7582
    }
 
7583
    name_vnp = ValNodeFree (name_vnp);
 
7584
  }
 
7585
  val = MemFree (val);
 
7586
  return err_list;
 
7587
}
 
7588
 
 
7589
 
 
7590
static void ClearValueListRow (ButtoN b)
 
7591
{
 
7592
  ValueListRowDialogPtr dlg;
 
7593
 
 
7594
  dlg = (ValueListRowDialogPtr) GetObjectExtra (b);
 
7595
 
 
7596
  if (dlg != NULL)
 
7597
  {  
 
7598
    PointerToDialog (dlg->dialog, NULL);
 
7599
    if (dlg->change_notify != NULL) 
 
7600
    {
 
7601
      (dlg->change_notify) (dlg->change_userdata);
 
7602
    }
 
7603
    SendMessageToDialog (dlg->parent_dlg, VIB_MSG_REDRAW);
 
7604
  }
 
7605
}
 
7606
 
 
7607
 
 
7608
static DialoG ValueListRowDialog (GrouP h, Int2 width, ValNodePtr choice_list, ValueListParentPtr parent,
 
7609
                                  TaglistCallback change_notify, Pointer change_userdata, DialoG parent_dlg)
 
7610
{
 
7611
  ValueListRowDialogPtr dlg;
 
7612
  GrouP           p, g;
 
7613
  Int4            i;
 
7614
  ValNode         vn;
 
7615
  ButtoN          b;
 
7616
 
 
7617
  p = HiddenGroup (h, 3, 0, NULL);
 
7618
  SetGroupSpacing (p, 2, 2);
 
7619
  dlg = (ValueListRowDialogPtr) MemNew (sizeof(ValueListRowDialogData));
 
7620
 
 
7621
  SetObjectExtra (p, dlg, StdCleanupExtraProc);
 
7622
  dlg->dialog = (DialoG) p;
 
7623
  dlg->todialog = NameValuePairToDialog;
 
7624
  dlg->fromdialog = DialogToNameValuePair;
 
7625
  dlg->testdialog = TestValueListRowDialog;
 
7626
  dlg->dialogmessage = NULL;
 
7627
  dlg->change_notify = change_notify;
 
7628
  dlg->change_userdata = change_userdata;
 
7629
  dlg->parent_dlg = parent_dlg;
 
7630
  
 
7631
  dlg->name_dlg = ValNodeSelectionDialog (p, CopyChoiceList(choice_list), 1, 
 
7632
                                     ValNodeStringName,
 
7633
                                     ValNodeSimpleDataFree, ValNodeStringCopy,
 
7634
                                     ValNodeStringMatch, NULL,
 
7635
                                     ChangeValueListRowName, dlg, FALSE);
 
7636
  vn.next = NULL;
 
7637
  vn.choice = 0;
 
7638
  vn.data.ptrvalue = " ";
 
7639
  PointerToDialog (dlg->name_dlg, &vn);
 
7640
 
 
7641
  g = HiddenGroup (p, 0, 0, NULL);
 
7642
  for (i = 0; i < eNumValueEditors; i++)
 
7643
  {
 
7644
    dlg->editors[i] = (value_edit_dialog_list[i]) (g, width, parent, change_notify, change_userdata);
 
7645
  }
 
7646
 
 
7647
  b = PushButton (p, "X", ClearValueListRow);
 
7648
  SetObjectExtra (b, dlg, NULL);
 
7649
 
 
7650
  ChangeValueListRowName (dlg);
 
7651
    
 
7652
  return (DialoG) p;
 
7653
}
 
7654
 
 
7655
typedef struct valuelistdialog {
 
7656
  DIALOG_MESSAGE_BLOCK
 
7657
  TaglistCallback change_notify;
 
7658
  Pointer         change_userdata;
 
7659
  Int4            num_rows;
 
7660
  DialoG *        rows;
 
7661
  BaR             left_bar;
 
7662
  BaR             right_bar;
 
7663
  ValNodePtr      choice_list;
 
7664
  ValNodePtr      value_list;
 
7665
  Int4            scroll_pos;
 
7666
  Boolean         suppress_notify;
 
7667
} ValueListDialogData, PNTR ValueListDialogPtr;
 
7668
 
 
7669
 
 
7670
static void CleanupValueListDialog (GraphiC g, VoidPtr data)
 
7671
 
 
7672
{
 
7673
  ValueListDialogPtr dlg;
 
7674
  
 
7675
  dlg = (ValueListDialogPtr) data;
 
7676
  if (dlg != NULL)
 
7677
  {
 
7678
    dlg->rows = MemFree (dlg->rows);
 
7679
  }
 
7680
 
 
7681
  StdCleanupExtraProc (g, data);
 
7682
}
 
7683
 
 
7684
 
 
7685
static NameValuePairPtr GetNthNameValuePair (Int4 n, ValNodePtr list)
 
7686
{
 
7687
  while (n > 0 && list != NULL)
 
7688
  {
 
7689
    n--;
 
7690
    list = list->next;
 
7691
  }
 
7692
  if (list == NULL)
 
7693
  {
 
7694
    return NULL;
 
7695
  }
 
7696
  else 
 
7697
  {
 
7698
    return (NameValuePairPtr) list->data.ptrvalue;
 
7699
  }
 
7700
}
 
7701
 
 
7702
static void PopulateValueListRows (ValueListDialogPtr dlg)
 
7703
{
 
7704
  Int4 n;
 
7705
  ValNodePtr vnp;
 
7706
 
 
7707
  n = dlg->scroll_pos;
 
7708
  vnp = dlg->value_list;
 
7709
 
 
7710
  dlg->suppress_notify = TRUE;
 
7711
 
 
7712
  while (n > 0 && vnp != NULL)
 
7713
  {
 
7714
    n--;
 
7715
    vnp = vnp->next;
 
7716
  }
 
7717
  for (n = 0; n < dlg->num_rows; n++)
 
7718
  {
 
7719
    if (vnp == NULL)
 
7720
    {  
 
7721
      PointerToDialog (dlg->rows[n], NULL);
 
7722
    }
 
7723
    else 
 
7724
    {
 
7725
      PointerToDialog (dlg->rows[n], vnp->data.ptrvalue);
 
7726
      vnp = vnp->next;
 
7727
    }
 
7728
  }
 
7729
  dlg->suppress_notify = FALSE;
 
7730
}
 
7731
 
 
7732
 
 
7733
static Boolean IsNameValuePairEmpty (NameValuePairPtr nvp)
 
7734
{
 
7735
  if (nvp == NULL) 
 
7736
  {
 
7737
    return TRUE;
 
7738
  }
 
7739
  else if ((nvp->name_vnp == NULL || nvp->name_vnp->choice == 0 || StringHasNoText (nvp->name_vnp->data.ptrvalue)) /* no choice */
 
7740
            && StringHasNoText (nvp->value)) /* no value */
 
7741
  {
 
7742
    return TRUE;
 
7743
  }
 
7744
  else 
 
7745
  {
 
7746
    return FALSE;
 
7747
  }
 
7748
}
 
7749
 
 
7750
/* Only trim blanks from the end of the list */
 
7751
static void RemoveBlanks (ValNodePtr PNTR pvnp)
 
7752
{
 
7753
  ValNodePtr vnp, last_non_blank = NULL;
 
7754
 
 
7755
  if (pvnp == NULL) return;
 
7756
 
 
7757
  vnp = *pvnp;
 
7758
  while (vnp != NULL) 
 
7759
  {
 
7760
    if (!IsNameValuePairEmpty ((NameValuePairPtr) vnp->data.ptrvalue)) 
 
7761
    {
 
7762
      last_non_blank = vnp;
 
7763
    }
 
7764
    vnp = vnp->next;
 
7765
  }
 
7766
  if (last_non_blank != NULL) {
 
7767
    last_non_blank->next = NameValuePairListFree (last_non_blank->next);
 
7768
  }
 
7769
}
 
7770
 
 
7771
static void ValueListPairToDialog (DialoG d, Pointer data)
 
7772
{
 
7773
  ValueListDialogPtr dlg;
 
7774
  Int4               num_vals;
 
7775
 
 
7776
  dlg = (ValueListDialogPtr) GetObjectExtra (d);
 
7777
  if (dlg == NULL) return;
 
7778
 
 
7779
  dlg->value_list = NameValuePairListFree (dlg->value_list);
 
7780
  dlg->value_list = (ValNodePtr) data;
 
7781
  RemoveBlanks (&(dlg->value_list));
 
7782
 
 
7783
  num_vals = ValNodeLen (dlg->value_list);
 
7784
  if (num_vals >= dlg->num_rows)
 
7785
  {
 
7786
    SetBarMax (dlg->left_bar, num_vals + 1 - dlg->num_rows);
 
7787
    SetBarMax (dlg->right_bar, num_vals + 1 - dlg->num_rows);
 
7788
  }
 
7789
  else
 
7790
  {
 
7791
    SetBarMax (dlg->left_bar, 0);
 
7792
    SetBarMax (dlg->right_bar, 0);
 
7793
  }
 
7794
  if (GetValue (dlg->left_bar) > GetBarMax (dlg->left_bar))
 
7795
  {
 
7796
    CorrectBarValue (dlg->left_bar, 0);
 
7797
    CorrectBarValue (dlg->right_bar, 0);
 
7798
  }
 
7799
  PopulateValueListRows (dlg);
 
7800
}
 
7801
 
 
7802
 
 
7803
static void ScrollValueListProc (BaR b, GraphiC g, Int2 _new, Int2 _old)
 
7804
{
 
7805
  ValueListDialogPtr dlg;
 
7806
 
 
7807
  dlg = (ValueListDialogPtr) GetObjectExtra (b);
 
7808
  if (dlg == NULL) return;
 
7809
 
 
7810
  /* synchronize left and right scroll bars */
 
7811
  if (b == dlg->right_bar && dlg->left_bar != NULL)
 
7812
  {
 
7813
    CorrectBarValue (dlg->left_bar, GetBarValue (dlg->right_bar));
 
7814
  }
 
7815
  else if (b == dlg->left_bar && dlg->right_bar != NULL)
 
7816
  {
 
7817
    CorrectBarValue (dlg->right_bar, GetBarValue (dlg->left_bar));      
 
7818
  }
 
7819
 
 
7820
  dlg->scroll_pos = _new;
 
7821
  PopulateValueListRows (dlg);
 
7822
}
 
7823
 
 
7824
 
 
7825
static void ValueListDialogMessage (DialoG d, Int2 mssg)
 
7826
 
 
7827
{
 
7828
  ValNodePtr         new_value_list;
 
7829
 
 
7830
  switch (mssg) {
 
7831
    case VIB_MSG_REDRAW :
 
7832
      new_value_list = DialogToPointer (d);
 
7833
      PointerToDialog (d, new_value_list);
 
7834
      break;
 
7835
    default :
 
7836
      break;
 
7837
  }
 
7838
}
 
7839
 
 
7840
 
 
7841
static void ChangeValueRow (Pointer data)
 
7842
{
 
7843
  ValueListDialogPtr dlg;
 
7844
  NameValuePairPtr   nvp;
 
7845
  Int4               max, i;
 
7846
  ValNodePtr         vnp;
 
7847
 
 
7848
  dlg = (ValueListDialogPtr) data;
 
7849
 
 
7850
  if (dlg == NULL) return;
 
7851
 
 
7852
  if (dlg->suppress_notify) return;
 
7853
 
 
7854
  /* copy values into list */
 
7855
  /* first, skip over rows scrolled past */
 
7856
  vnp = dlg->value_list;
 
7857
  i = 0;
 
7858
  while (i < dlg->scroll_pos)
 
7859
  {
 
7860
    if (vnp == NULL)
 
7861
    {
 
7862
      vnp = ValNodeAddPointer (&dlg->value_list, 0, NULL);
 
7863
    }
 
7864
    vnp = vnp->next;
 
7865
    i++;
 
7866
  }
 
7867
  
 
7868
  /* now copy in rows we can see */    
 
7869
  for (i = 0; i < dlg->num_rows; i++)
 
7870
  {
 
7871
    if (vnp == NULL)
 
7872
    {
 
7873
      vnp = ValNodeAddPointer (&dlg->value_list, 0, DialogToPointer (dlg->rows[i]));
 
7874
    }
 
7875
    else
 
7876
    {
 
7877
      vnp->data.ptrvalue = NameValuePairFree (vnp->data.ptrvalue);
 
7878
      vnp->data.ptrvalue = DialogToPointer (dlg->rows[i]);
 
7879
    }
 
7880
    vnp = vnp->next;
 
7881
  }
 
7882
  
 
7883
 
 
7884
  /* if editing last row, extend scrollbar for new row */
 
7885
  max = GetBarMax (dlg->left_bar);
 
7886
  if (dlg->scroll_pos == max)
 
7887
  {
 
7888
    nvp = DialogToPointer (dlg->rows[dlg->num_rows - 1]);
 
7889
    if (!IsNameValuePairEmpty (nvp))
 
7890
    {
 
7891
      SetBarMax (dlg->left_bar, max + 1);
 
7892
      SetBarMax (dlg->right_bar, max + 1); 
 
7893
    }
 
7894
    nvp = NameValuePairFree(nvp);    
 
7895
  }   
 
7896
 
 
7897
  if (dlg->change_notify != NULL)
 
7898
  {
 
7899
    (dlg->change_notify)(dlg->change_userdata);
 
7900
  }
 
7901
}
 
7902
 
 
7903
 
 
7904
static Pointer DialogToNameValuePairList (DialoG d)
 
7905
{
 
7906
  ValueListDialogPtr dlg;
 
7907
  ValNodePtr         value_list = NULL, vnp;
 
7908
 
 
7909
  dlg = (ValueListDialogPtr) GetObjectExtra (d);
 
7910
  if (dlg == NULL) return NULL;
 
7911
 
 
7912
  for (vnp = dlg->value_list; vnp != NULL; vnp = vnp->next)
 
7913
  {
 
7914
    if (vnp->data.ptrvalue != NULL) 
 
7915
    {
 
7916
      ValNodeAddPointer (&value_list, 0, NameValuePairCopy (vnp->data.ptrvalue));
 
7917
    }
 
7918
  }
 
7919
  return (Pointer) value_list;
 
7920
}
 
7921
 
 
7922
 
 
7923
static ValNodePtr TestValueListDialog (DialoG d)
 
7924
{
 
7925
  ValNodePtr       err_list = NULL, value_list = NULL, vnp;
 
7926
  NameValuePairPtr nvp;
 
7927
  CharPtr          err_fmt = "No modifier type selected for data %s";
 
7928
  CharPtr          err_str;
 
7929
 
 
7930
  value_list = DialogToPointer (d);
 
7931
 
 
7932
  for (vnp = value_list; vnp != NULL; vnp = vnp->next)
 
7933
  {
 
7934
    nvp = (NameValuePairPtr) vnp->data.ptrvalue;
 
7935
    if (nvp != NULL 
 
7936
        && !StringHasNoText (nvp->value) 
 
7937
        && (nvp->name_vnp == NULL || StringHasNoText (nvp->name_vnp->data.ptrvalue)))
 
7938
    {
 
7939
      err_str = (CharPtr) MemNew (sizeof (Char) * (StringLen (err_fmt) + StringLen (nvp->value)));
 
7940
      sprintf (err_str, err_fmt, nvp->value);
 
7941
      ValNodeAddPointer (&err_list, 0, err_str);
 
7942
    }
 
7943
  }
 
7944
  value_list = NameValuePairListFree (value_list);
 
7945
  return err_list;
 
7946
}
 
7947
 
 
7948
extern DialoG ValueListDialog (GrouP h, Uint2 num_rows, Int2 width, ValNodePtr choice_list, ValueListParentPtr parent, TaglistCallback change_notify, Pointer change_userdata)
 
7949
{
 
7950
  ValueListDialogPtr dlg;
 
7951
  GrouP           p, g;
 
7952
  Int4            i;
 
7953
 
 
7954
  p = HiddenGroup (h, 3, 0, NULL);
 
7955
  SetGroupSpacing (p, 2, 2);
 
7956
  dlg = (ValueListDialogPtr) MemNew (sizeof(ValueListDialogData));
 
7957
 
 
7958
  SetObjectExtra (p, dlg, CleanupValueListDialog);
 
7959
  dlg->dialog = (DialoG) p;
 
7960
  dlg->todialog = ValueListPairToDialog;
 
7961
  dlg->fromdialog = DialogToNameValuePairList;
 
7962
  dlg->testdialog = TestValueListDialog;
 
7963
  dlg->dialogmessage = ValueListDialogMessage;
 
7964
  dlg->change_notify = change_notify;
 
7965
  dlg->change_userdata = change_userdata;
 
7966
  
 
7967
  dlg->num_rows = num_rows;
 
7968
 
 
7969
  /* navigation bar on left */
 
7970
  dlg->left_bar = ScrollBar (p, 0, dlg->num_rows, ScrollValueListProc);
 
7971
  SetObjectExtra (dlg->left_bar, dlg, NULL);
 
7972
  CorrectBarPage (dlg->left_bar, dlg->num_rows - 1, dlg->num_rows - 1);
 
7973
 
 
7974
  g = HiddenGroup (p, 1, 0, NULL);
 
7975
  dlg->rows = (DialoG *) MemNew (num_rows * sizeof (DialoG));
 
7976
  for (i = 0; i < dlg->num_rows; i++)
 
7977
  {
 
7978
    dlg->rows[i] = ValueListRowDialog (g, width, choice_list, parent, ChangeValueRow, dlg, (DialoG) p);
 
7979
 
 
7980
  }
 
7981
 
 
7982
  /* navigation bar on right */
 
7983
  dlg->right_bar = ScrollBar (p, 0, dlg->num_rows, ScrollValueListProc);
 
7984
  SetObjectExtra (dlg->right_bar, dlg, NULL);
 
7985
  CorrectBarPage (dlg->right_bar, dlg->num_rows - 1, dlg->num_rows - 1);
 
7986
 
 
7987
  AlignObjects (ALIGN_LOWER, (HANDLE) g, (HANDLE) dlg->left_bar, (HANDLE) dlg->right_bar, NULL);
 
7988
 
 
7989
 
 
7990
  return (DialoG) p;
 
7991
}
 
7992
 
 
7993
 
 
7994
typedef struct modifierlistdlg {
 
7995
  VALUE_LIST_PARENT_FIELDS
 
7996
 
 
7997
  DialoG dlg;
 
7998
  ButtoN type_strain;
 
7999
  TexT   taxname;
 
8000
 
 
8001
  EnumFieldAssocPtr al;
 
8002
} ModifierListDlgData, PNTR ModifierListDlgPtr;
 
8003
 
 
8004
 
 
8005
static ValNodePtr TestModifierListDlg (DialoG d)
 
8006
{
 
8007
  ModifierListDlgPtr dlg = (ModifierListDlgPtr) GetObjectExtra (d);
 
8008
  if (dlg == NULL) return NULL;
 
8009
  return TestDialog (dlg->dlg);
 
8010
}
 
8011
 
 
8012
 
 
8013
 
 
8014
static ValNodePtr SubSourceListToNameValueList (SubSourcePtr ssp)
 
8015
{
 
8016
  ValNodePtr val_list = NULL;
 
8017
  NameValuePairPtr nvp;
 
8018
 
 
8019
  while (ssp != NULL)
 
8020
  {
 
8021
    if (ssp->subtype != SUBSRC_other)
 
8022
    {
 
8023
      nvp = (NameValuePairPtr) MemNew (sizeof (NameValuePairData));
 
8024
      nvp->name_vnp = ValNodeNew(NULL);
 
8025
      nvp->name_vnp->choice = 1;
 
8026
      nvp->name_vnp->data.ptrvalue = StringSave (GetSubsourceQualName (ssp->subtype));
 
8027
      nvp->value = StringSave (ssp->name);
 
8028
      ValNodeAddPointer (&val_list, 0, nvp);
 
8029
    }
 
8030
    ssp = ssp->next;
 
8031
  }
 
8032
  return val_list;
 
8033
 
 
8034
}
 
8035
 
 
8036
 
 
8037
static void SubSourceListToDialog (DialoG d, Pointer data)
 
8038
{
 
8039
  ModifierListDlgPtr dlg;
 
8040
  SubSourcePtr ssp;
 
8041
  ValNodePtr   vnp;
 
8042
  CharPtr      note_txt = NULL;
 
8043
 
 
8044
  dlg = (ModifierListDlgPtr) GetObjectExtra (d);
 
8045
 
 
8046
  if (dlg == NULL) return;
 
8047
 
 
8048
  ssp = (SubSourcePtr) data;
 
8049
 
 
8050
  vnp = SubSourceListToNameValueList (ssp);
 
8051
  PointerToDialog (dlg->dlg, vnp);
 
8052
 
 
8053
  while (ssp != NULL) 
 
8054
  {
 
8055
    if (ssp->subtype == SUBSRC_other)
 
8056
    {
 
8057
      note_txt = combine_strings (note_txt, ssp->name);
 
8058
    }
 
8059
    ssp = ssp->next;
 
8060
  }
 
8061
  SetTitle (dlg->note, note_txt);
 
8062
 
 
8063
}
 
8064
 
 
8065
 
 
8066
static Pointer DialogToSubSourceList (DialoG d)
 
8067
{
 
8068
  ModifierListDlgPtr dlg;
 
8069
  ValNodePtr   val_list, vnp;
 
8070
  NameValuePairPtr nvp;
 
8071
  SubSourcePtr     ssp_list = NULL, ssp_prev = NULL, ssp_new;
 
8072
  Uint1            subtype;
 
8073
  CharPtr          comment_str;
 
8074
 
 
8075
  dlg = (ModifierListDlgPtr) GetObjectExtra (d);
 
8076
 
 
8077
  if (dlg == NULL) return NULL;
 
8078
 
 
8079
  val_list = (ValNodePtr) DialogToPointer (dlg->dlg);
 
8080
  for (vnp = val_list; vnp != NULL; vnp = vnp->next)
 
8081
  {
 
8082
    if (vnp->data.ptrvalue != NULL) 
 
8083
    {
 
8084
      nvp = (NameValuePairPtr) vnp->data.ptrvalue;
 
8085
      if (nvp != NULL && nvp->name_vnp != NULL)
 
8086
      {        
 
8087
        subtype = EquivalentSubSourceEx (nvp->name_vnp->data.ptrvalue, TRUE);
 
8088
        if (subtype != 0)
 
8089
        {
 
8090
          ssp_new = SubSourceNew ();
 
8091
          ssp_new->subtype = subtype;
 
8092
          ssp_new->name = StringSave (nvp->value == NULL ? "" : nvp->value);
 
8093
          if (ssp_prev == NULL)
 
8094
          {
 
8095
            ssp_list = ssp_new;
 
8096
          }
 
8097
          else
 
8098
          {
 
8099
            ssp_prev->next = ssp_new;
 
8100
          }
 
8101
          ssp_prev = ssp_new;
 
8102
        }
 
8103
      }
 
8104
    }
 
8105
  }
 
8106
  val_list = NameValuePairListFree (val_list);
 
8107
 
 
8108
  /* add comment */
 
8109
  comment_str = SaveStringFromText (dlg->note);
 
8110
  if (!StringHasNoText (comment_str))
 
8111
  {
 
8112
    ssp_new = SubSourceNew();
 
8113
    ssp_new->subtype = SUBSRC_other;
 
8114
    ssp_new->name = StringSave (comment_str);
 
8115
    if (ssp_prev == NULL)
 
8116
    {
 
8117
      ssp_list = ssp_new;
 
8118
    }
 
8119
    else
 
8120
    {
 
8121
      ssp_prev->next = ssp_new;
 
8122
    }
 
8123
    ssp_prev = ssp_new;
 
8124
  }
 
8125
 
 
8126
  return ssp_list;
 
8127
}
 
8128
 
 
8129
 
 
8130
static ValNodePtr GetSubSourceChoicesForValueList (EnumFieldAssocPtr al)
 
8131
{
 
8132
  ValNodePtr choice_list = NULL;
 
8133
  EnumFieldAssocPtr efap;
 
8134
 
 
8135
  efap = al;
 
8136
  while (efap->name != NULL)
 
8137
  {
 
8138
    if (StringHasNoText (efap->name))
 
8139
    {
 
8140
      ValNodeAddStr (&choice_list, eValueEditSimpleText + 1, StringSave (efap->name));
 
8141
    }
 
8142
    else if (efap->value == SUBSRC_lat_lon)
 
8143
    {
 
8144
      ValNodeAddStr (&choice_list, eValueEditLatLon + 1, StringSave (efap->name));
 
8145
    }
 
8146
    else if (IsNonTextModifier (efap->name))
 
8147
    {
 
8148
      ValNodeAddStr (&choice_list, eValueEditTrueFalse + 1, StringSave (efap->name));
 
8149
    }
 
8150
    else
 
8151
    {
 
8152
      ValNodeAddStr (&choice_list, eValueEditSimpleText + 1, StringSave (efap->name));
 
8153
    }
 
8154
    efap ++;
 
8155
  }
 
8156
  return choice_list;
 
8157
}
 
8158
 
 
8159
 
 
8160
static CharPtr subsource_extra_prompts [] = {
 
8161
  "Additional", "Source", "Information", NULL
 
8162
};
 
8163
 
 
8164
extern DialoG CreateSubSourceDialog (GrouP h, EnumFieldAssocPtr al)
 
8165
{
 
8166
  ModifierListDlgPtr dlg;
 
8167
  GrouP        p, g, x;
 
8168
  ValNodePtr   choice_list;
 
8169
  Int2         max;
 
8170
  
 
8171
 
 
8172
  p = HiddenGroup (h, -1, 0, NULL);
 
8173
  SetGroupSpacing (p, 10, 10);
 
8174
  dlg = (ModifierListDlgPtr) MemNew (sizeof(ModifierListDlgData));
 
8175
 
 
8176
  SetObjectExtra (p, dlg, StdCleanupExtraProc);
 
8177
  dlg->dialog = (DialoG) p;
 
8178
  dlg->todialog = SubSourceListToDialog;
 
8179
  dlg->fromdialog = DialogToSubSourceList;
 
8180
  dlg->testdialog = TestModifierListDlg;
 
8181
  dlg->dialogmessage = NULL;
 
8182
 
 
8183
  choice_list = GetSubSourceChoicesForValueList (al);
 
8184
  dlg->dlg = ValueListDialog (p, 3, 23, choice_list, (ValueListParentPtr) dlg, NULL, NULL);  
 
8185
  choice_list = ValNodeFreeData (choice_list);
 
8186
 
 
8187
  g = HiddenGroup (p, 2, 0, NULL);
 
8188
  SelectFont (programFont);
 
8189
  max = MaxStringWidths (subsource_extra_prompts) + 2;
 
8190
  x = MultiLinePrompt (g, "Additional Source Information", max, programFont);
 
8191
  dlg->note = ScrollText (g, 20, 3, programFont, TRUE, NULL);
 
8192
  AlignObjects (ALIGN_MIDDLE, (HANDLE) x, (HANDLE) dlg->note, NULL);
 
8193
 
 
8194
  AlignObjects (ALIGN_CENTER, (HANDLE) dlg->dlg, (HANDLE) g, NULL);
 
8195
 
 
8196
  return (DialoG) p;
 
8197
}
 
8198
 
 
8199
 
 
8200
static ValNodePtr OrgModListToNameValueList (OrgModPtr mod)
 
8201
{
 
8202
  ValNodePtr val_list = NULL;
 
8203
  NameValuePairPtr nvp;
 
8204
 
 
8205
  while (mod != NULL)
 
8206
  {
 
8207
    if (mod->subtype != ORGMOD_gb_acronym
 
8208
        && mod->subtype != ORGMOD_gb_anamorph
 
8209
        && mod->subtype != ORGMOD_gb_synonym
 
8210
        && mod->subtype != ORGMOD_other)
 
8211
    {
 
8212
      nvp = (NameValuePairPtr) MemNew (sizeof (NameValuePairData));
 
8213
      nvp->name_vnp = ValNodeNew(NULL);
 
8214
      nvp->name_vnp->choice = 1;
 
8215
      nvp->name_vnp->data.ptrvalue = StringSave (GetOrgModQualName (mod->subtype));
 
8216
      nvp->value = StringSave (mod->subname);
 
8217
      ValNodeAddPointer (&val_list, 0, nvp);
 
8218
    }
 
8219
    mod = mod->next;
 
8220
  }
 
8221
  return val_list;
 
8222
 
 
8223
}
 
8224
 
 
8225
 
 
8226
static void OrgModListToDialog (DialoG d, Pointer data)
 
8227
{
 
8228
  ModifierListDlgPtr dlg;
 
8229
  OrgModPtr          mod;
 
8230
  ValNodePtr         vnp;
 
8231
  CharPtr            note_txt = NULL;
 
8232
 
 
8233
  dlg = (ModifierListDlgPtr) GetObjectExtra (d);
 
8234
 
 
8235
  if (dlg == NULL) return;
 
8236
 
 
8237
  mod = (OrgModPtr) data;
 
8238
 
 
8239
  vnp = OrgModListToNameValueList (mod);
 
8240
  PointerToDialog (dlg->dlg, vnp);
 
8241
 
 
8242
  while (mod != NULL) 
 
8243
  {
 
8244
    if (mod->subtype == ORGMOD_other)
 
8245
    {
 
8246
      note_txt = combine_strings (note_txt, mod->subname);
 
8247
    }
 
8248
    mod = mod->next;
 
8249
  }
 
8250
  SetTitle (dlg->note, note_txt);
 
8251
 
 
8252
}
 
8253
 
 
8254
 
 
8255
static Pointer DialogToOrgModList (DialoG d)
 
8256
{
 
8257
  ModifierListDlgPtr dlg;
 
8258
  ValNodePtr   val_list, vnp;
 
8259
  NameValuePairPtr nvp;
 
8260
  OrgModPtr        mod_list = NULL, mod_prev = NULL, mod_new;
 
8261
  Uint1            subtype;
 
8262
  CharPtr          comment_str;
 
8263
 
 
8264
  dlg = (ModifierListDlgPtr) GetObjectExtra (d);
 
8265
 
 
8266
  if (dlg == NULL) return NULL;
 
8267
 
 
8268
  val_list = (ValNodePtr) DialogToPointer (dlg->dlg);
 
8269
  for (vnp = val_list; vnp != NULL; vnp = vnp->next)
 
8270
  {
 
8271
    if (vnp->data.ptrvalue != NULL) 
 
8272
    {
 
8273
      nvp = (NameValuePairPtr) vnp->data.ptrvalue;
 
8274
      if (nvp != NULL && nvp->name_vnp != NULL)
 
8275
      {        
 
8276
        subtype = EquivalentOrgModEx (nvp->name_vnp->data.ptrvalue, TRUE);
 
8277
        if (subtype != 0)
 
8278
        {
 
8279
          mod_new = OrgModNew ();
 
8280
          mod_new->subtype = subtype;
 
8281
          mod_new->subname = StringSave (nvp->value == NULL ? "" : nvp->value);
 
8282
          if (mod_prev == NULL)
 
8283
          {
 
8284
            mod_list = mod_new;
 
8285
          }
 
8286
          else
 
8287
          {
 
8288
            mod_prev->next = mod_new;
 
8289
          }
 
8290
          mod_prev = mod_new;
 
8291
        }
 
8292
      }
 
8293
    }
 
8294
  }
 
8295
  val_list = NameValuePairListFree (val_list);
 
8296
 
 
8297
  /* add comment */
 
8298
  comment_str = SaveStringFromText (dlg->note);
 
8299
  if (!StringHasNoText (comment_str))
 
8300
  {
 
8301
    mod_new = OrgModNew();
 
8302
    mod_new->subtype = ORGMOD_other;
 
8303
    mod_new->subname = StringSave (comment_str);
 
8304
    if (mod_prev == NULL)
 
8305
    {
 
8306
      mod_list = mod_new;
 
8307
    }
 
8308
    else
 
8309
    {
 
8310
      mod_prev->next = mod_new;
 
8311
    }
 
8312
    mod_prev = mod_new;
 
8313
  }
 
8314
 
 
8315
  return mod_list;
 
8316
}
 
8317
 
 
8318
 
 
8319
extern Boolean IsNonTextModifier (CharPtr mod_name)
 
8320
{
 
8321
  if (StringICmp (mod_name, "transgenic") == 0
 
8322
      || StringICmp (mod_name, "germline") == 0
 
8323
      || StringICmp (mod_name, "metagenomic") == 0
 
8324
      || StringICmp (mod_name, "environmental-sample") ==0
 
8325
      || StringICmp (mod_name, "rearranged") == 0)
 
8326
  {
 
8327
    return TRUE;  
 
8328
  }
 
8329
  else
 
8330
  {
 
8331
    return FALSE;
 
8332
  }
 
8333
}
 
8334
 
 
8335
 
 
8336
static ValNodePtr GetOrgModChoicesForValueList (EnumFieldAssocPtr al)
 
8337
{
 
8338
  ValNodePtr choice_list = NULL;
 
8339
  EnumFieldAssocPtr efap;
 
8340
 
 
8341
  efap = al;
 
8342
  while (efap->name != NULL)
 
8343
  {
 
8344
    if (StringHasNoText (efap->name))
 
8345
    {
 
8346
      ValNodeAddStr (&choice_list, eValueEditSimpleText + 1, StringSave (efap->name));
 
8347
    }
 
8348
    else if (IsNonTextModifier (efap->name))
 
8349
    {
 
8350
      ValNodeAddStr (&choice_list, eValueEditTrueFalse + 1, StringSave (efap->name));
 
8351
    }
 
8352
    else if (efap->value == ORGMOD_specimen_voucher || efap->value == ORGMOD_culture_collection || efap->value == ORGMOD_bio_material)
 
8353
    {
 
8354
      ValNodeAddStr (&choice_list, eValueEditSpecimenVoucher + 1, StringSave (efap->name));
 
8355
    }
 
8356
    else
 
8357
    {
 
8358
      ValNodeAddStr (&choice_list, eValueEditSimpleText + 1, StringSave (efap->name));
 
8359
    }
 
8360
    efap ++;
 
8361
  }
 
8362
  return choice_list;
 
8363
}
 
8364
 
 
8365
 
 
8366
static CharPtr orgmod_extra_prompts [] = {
 
8367
  "Additional", "Organism", "Information", NULL
 
8368
};
 
8369
 
 
8370
static void ChangeOrgmodComment (TexT t)
 
8371
{
 
8372
  ModifierListDlgPtr dlg;
 
8373
  CharPtr str;
 
8374
 
 
8375
  dlg = (ModifierListDlgPtr) GetObjectExtra (t);
 
8376
  if (dlg == NULL) return;
 
8377
 
 
8378
  str = SaveStringFromText (t);
 
8379
  if ( StringStr (str, "type strain of ")) {
 
8380
    Disable (dlg->type_strain);
 
8381
  }
 
8382
 
 
8383
}  
 
8384
 
 
8385
 
 
8386
static void AddTypeStrainProc (ButtoN b)
 
8387
{
 
8388
  ModifierListDlgPtr dlg;
 
8389
  CharPtr        old_orgcomment;
 
8390
  Int4           old_orgcomment_len;
 
8391
  CharPtr        org_name;
 
8392
  Int4           org_name_len;
 
8393
  const CharPtr  ts = "type strain of ";
 
8394
  const CharPtr  sep = "; ";
 
8395
  CharPtr        new_orgcomment;
 
8396
 
 
8397
  dlg = (ModifierListDlgPtr) GetObjectExtra (b);
 
8398
  if (dlg == NULL) return;
 
8399
 
 
8400
  old_orgcomment_len = TextLength (dlg->note) + 1;
 
8401
  old_orgcomment = MemNew (old_orgcomment_len + 1);
 
8402
  if (old_orgcomment == NULL) return;
 
8403
  org_name_len = TextLength (dlg->taxname) + 1;
 
8404
  org_name = MemNew (org_name_len + 1);
 
8405
  if (org_name == NULL) 
 
8406
  {
 
8407
    MemFree (old_orgcomment);
 
8408
    return;
 
8409
  }
 
8410
  new_orgcomment = MemNew (old_orgcomment_len
 
8411
                        + StringLen (sep)
 
8412
                        + StringLen (ts)
 
8413
                        + org_name_len
 
8414
                        + 1);
 
8415
  if (new_orgcomment == NULL)
 
8416
  {
 
8417
    MemFree (old_orgcomment);
 
8418
    MemFree (org_name);
 
8419
  }
 
8420
 
 
8421
  GetTitle (dlg->note, old_orgcomment, old_orgcomment_len);
 
8422
  TrimSpacesAroundString (old_orgcomment);
 
8423
  GetTitle (dlg->taxname, org_name, org_name_len);
 
8424
  TrimSpacesAroundString (org_name);
 
8425
  if (old_orgcomment[0] != 0)
 
8426
  {
 
8427
    StringCpy(new_orgcomment, old_orgcomment);
 
8428
    StringCat(new_orgcomment, sep);
 
8429
  }
 
8430
  else
 
8431
  {
 
8432
    new_orgcomment[0] = 0;
 
8433
  }
 
8434
    
 
8435
  StringCat (new_orgcomment, ts);
 
8436
  StringCat (new_orgcomment, org_name);
 
8437
  SetTitle (dlg->note, new_orgcomment);
 
8438
  MemFree (org_name);
 
8439
  MemFree (old_orgcomment);
 
8440
  MemFree (new_orgcomment);
 
8441
  Disable (b);
 
8442
}
 
8443
 
 
8444
 
 
8445
extern DialoG CreateOrgModDialog (GrouP h, EnumFieldAssocPtr al, TexT taxname)
 
8446
{
 
8447
  ModifierListDlgPtr dlg;
 
8448
  GrouP        p, g, x;
 
8449
  ValNodePtr   choice_list;
 
8450
  Int2         max;
 
8451
  
 
8452
 
 
8453
  p = HiddenGroup (h, -1, 0, NULL);
 
8454
  SetGroupSpacing (p, 10, 10);
 
8455
  dlg = (ModifierListDlgPtr) MemNew (sizeof(ModifierListDlgData));
 
8456
 
 
8457
  SetObjectExtra (p, dlg, StdCleanupExtraProc);
 
8458
  dlg->dialog = (DialoG) p;
 
8459
  dlg->todialog = OrgModListToDialog;
 
8460
  dlg->fromdialog = DialogToOrgModList;
 
8461
  dlg->testdialog = TestModifierListDlg;
 
8462
  dlg->dialogmessage = NULL;
 
8463
 
 
8464
  choice_list = GetOrgModChoicesForValueList (al);
 
8465
  dlg->dlg = ValueListDialog (p, 3, 23, choice_list, (ValueListParentPtr) dlg, NULL, NULL);  
 
8466
  choice_list = ValNodeFreeData (choice_list);
 
8467
 
 
8468
  g = HiddenGroup (p, 2, 0, NULL);
 
8469
  SelectFont (programFont);
 
8470
  max = MaxStringWidths (orgmod_extra_prompts) + 2;
 
8471
  x = MultiLinePrompt (g, "Additional Organism Information", max, programFont);
 
8472
  dlg->note = ScrollText (g, 20, 3, programFont, TRUE, ChangeOrgmodComment);
 
8473
  SetObjectExtra (dlg->note, dlg, NULL);
 
8474
  AlignObjects (ALIGN_MIDDLE, (HANDLE) x, (HANDLE) dlg->note, NULL);
 
8475
 
 
8476
  dlg->taxname = taxname;
 
8477
  if (dlg->taxname != NULL)
 
8478
  {
 
8479
    dlg->type_strain = PushButton (p, "Add type strain to comment", AddTypeStrainProc);
 
8480
    SetObjectExtra (dlg->type_strain, dlg, NULL);
 
8481
  }
 
8482
  else
 
8483
  {
 
8484
    dlg->type_strain = NULL;
 
8485
  }
 
8486
 
 
8487
  AlignObjects (ALIGN_CENTER, (HANDLE) dlg->dlg, (HANDLE) g, (HANDLE) dlg->type_strain, NULL);
 
8488
 
 
8489
  return (DialoG) p;
 
8490
}
 
8491
 
 
8492
 
 
8493
extern void CreateStandardEditMenu (WindoW w)
 
8494
{
 
8495
  MenU m;
 
8496
  IteM i;
 
8497
 
 
8498
  /* Edit Menu */
 
8499
  m = PulldownMenu (w, "Edit");
 
8500
  i = CommandItem (m, "Cut", StdCutTextProc);
 
8501
  i = CommandItem (m, "Copy", StdCopyTextProc);
 
8502
  i = CommandItem (m, "Paste", StdPasteTextProc);
 
8503
  i = CommandItem (m, "Clear", StdDeleteTextProc);
 
8504
 
 
8505
}
 
8506