← Back to branch summary

~ubuntu-branches/ubuntu/saucy/ncbi-tools6/saucy-proposed

« back to all changes in this revision

Viewing changes to desktop/vsmutil.c

  • Committer: Bazaar Package Importer
  • Author(s): Aaron M. Ucko
  • Date: 2009-08-11 22:03:47 UTC
  • mfrom: (1.4.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20090811220347-g4b6lzdvphvvbpiu
* New upstream release.
* debian/libncbi6.symbols: update accordingly.
* debian/control: clean up obsolete or redundant relationship declarations.

Show diffs side-by-side

added added

removed removed

Lines of Context:
desktop/vsmutil.c
29
29
*
30
30
* Version Creation Date:   3/3/95
31
31
*
32
 
* $Revision: 6.61 $
 
32
* $Revision: 6.66 $
33
33
*
34
34
* File Description: 
35
35
*
76
76
  CharPtr  catname;
77
77
  CharPtr  errname;
78
78
  CharPtr  accession;
 
79
  CharPtr  featureID;
79
80
  CharPtr  message;
80
81
  CharPtr  objtype;
81
82
  CharPtr  label;
114
115
  BaseFormPtr    bfp;
115
116
  FormActnFunc   revalProc;
116
117
  ButtoN         revalBtn;
 
118
  FormActnFunc   continueProc;
 
119
  ButtoN         continueBtn;
117
120
  Boolean        okaytosetviewtarget;
118
121
  Boolean        indexerVersion;
119
122
  Int2           selected_text_start_item;
128
131
  Int2           selected_text_anchor_col;
129
132
  Int2           selected_text_anchor_row;
130
133
  Int4           selected_text_anchor_offset;
 
134
  SequesterProc  sequesterProc;
131
135
} ValidExtra, PNTR ValidExtraPtr;
132
136
 
133
137
static WindoW  validWindow = NULL;
360
364
  return sfp;
361
365
}
362
366
 
 
367
 
 
368
static Boolean FindSdpItem (GatherContextPtr gcp)
 
369
 
 
370
{
 
371
  SeqDescrPtr  PNTR sdpp;
 
372
 
 
373
  sdpp = (SeqDescrPtr PNTR) gcp->userdata;
 
374
  if (sdpp != NULL && gcp->thistype == OBJ_SEQDESC) {
 
375
    *sdpp = (SeqDescrPtr) gcp->thisitem;
 
376
  }
 
377
  return TRUE;
 
378
}
 
379
 
 
380
static SeqDescrPtr GetSeqDescGivenIDs (Uint2 entityID, Uint4 itemID, Uint2 itemtype)
 
381
 
 
382
{
 
383
  SeqDescrPtr  sdp;
 
384
 
 
385
  sdp = NULL;
 
386
  if (entityID > 0 && itemID > 0 && itemtype == OBJ_SEQFEAT) {
 
387
    GatherItem (entityID, itemID, itemtype, (Pointer) (&sdp), FindSdpItem);
 
388
  }
 
389
  return sdp;
 
390
}
 
391
 
 
392
 
 
393
 
363
394
static void ValDoNotify (ValidExtraPtr vep, Int2 item, Boolean select, Boolean target)
364
395
 
365
396
{
525
556
    MemFree (eip->catname);
526
557
    MemFree (eip->errname);
527
558
    MemFree (eip->accession);
 
559
    MemFree (eip->featureID);
528
560
    MemFree (eip->message);
529
561
    MemFree (eip->objtype);
530
562
    MemFree (eip->label);
644
676
        StringLen (eip->catname) +
645
677
        StringLen (eip->errname) +
646
678
        StringLen (eip->accession) +
 
679
        StringLen (eip->featureID) +
647
680
        StringLen (eip->message) +
648
681
        StringLen (eip->objtype) +
649
682
        StringLen (eip->label) +
1142
1175
}
1143
1176
 
1144
1177
 
1145
 
static ValNodePtr CollectValidatorReportTypes (ValidExtraPtr vep)
1146
 
{
1147
 
  ErrFltrPtr  efp;
1148
 
  ValNodePtr  chosen = NULL, vnp;
1149
 
  WindoW      w, h, btn_grp, g1 = NULL, c;
1150
 
  Int4        num_buttons, i;
1151
 
  ValidatorReportTypeData data;
1152
 
  ButtoN PNTR btn_array;
1153
 
  ButtoN      b;
1154
 
  int         last_errcode = 0;
1155
 
  ModalAcceptCancelData acd;
1156
 
  
1157
 
  if (vep == NULL || vep->errorfilter == NULL) return NULL;
1158
 
 
1159
 
  /* if only one, just select the one */
1160
 
  if (vep->errorfilter->next == NULL) 
1161
 
  {
1162
 
    ValNodeAddPointer (&chosen, 0, vep->errorfilter->data.ptrvalue);
1163
 
    return chosen;
1164
 
  }
1165
 
 
1166
 
  num_buttons = ValNodeLen (vep->errorfilter);
1167
 
  btn_array = (ButtoN PNTR) MemNew (sizeof (ButtoN) * num_buttons);
1168
 
 
1169
 
  data.btn_array = btn_array;
1170
 
  data.errorfilter = vep->errorfilter;
1171
 
 
1172
 
  w = MovableModalWindow (-50, -33, -10, -10, "Choose Report Items", NULL);
1173
 
  SetGroupSpacing (w, 10, 10);
1174
 
  h = HiddenGroup (w, -1, 0, NULL);
1175
 
  SetGroupSpacing (h, 10, 10);
1176
 
 
1177
 
  btn_grp = HiddenGroup (h, 3, 0, NULL);
1178
 
  for (vnp = vep->errorfilter, i = 0; vnp != NULL; vnp = vnp->next, i++) {
1179
 
    efp = (ErrFltrPtr) vnp->data.ptrvalue;
1180
 
    if (efp == NULL) continue;
1181
 
    if (efp->subcode == INT_MIN) {
1182
 
      g1 = NormalGroup (btn_grp, 0, 10, efp->text2, programFont, NULL);
1183
 
      btn_array[i] = CheckBox (g1, "All", EnableValidatorReportTypeButtons);
1184
 
      SetObjectExtra (btn_array[i], &data, NULL);
1185
 
      last_errcode = efp->errcode;
1186
 
    } else {
1187
 
      if (last_errcode != efp->errcode) {
1188
 
        g1 = NULL;
1189
 
      }
1190
 
      btn_array[i] = CheckBox (g1 == NULL ? btn_grp : g1, efp->text3 == NULL ? "" : efp->text3, NULL);
1191
 
    }
1192
 
  }
1193
 
 
1194
 
  c = HiddenGroup (w, 4, 0, NULL);
1195
 
  SetGroupSpacing (c, 10, 2);
1196
 
  b = DefaultButton (c, "Accept", ModalAcceptButton);
1197
 
  SetObjectExtra (b, &acd, NULL);
1198
 
  b = PushButton (c, "Cancel", ModalCancelButton);
1199
 
  SetObjectExtra (b, &acd, NULL);
1200
 
 
1201
 
  AlignObjects (ALIGN_CENTER, (HANDLE) btn_grp, (HANDLE) c, NULL);
1202
 
  RealizeWindow (w);
1203
 
 
1204
 
  Show (w);
1205
 
  Select (w);
1206
 
  Update ();
1207
 
 
1208
 
  acd.accepted = FALSE;
1209
 
  acd.cancelled = FALSE;
1210
 
  
1211
 
  while (!acd.accepted && ! acd.cancelled)
1212
 
  {
1213
 
    while (!acd.accepted && ! acd.cancelled)
1214
 
    {
1215
 
      ProcessExternalEvent ();
1216
 
      Update ();
1217
 
    }
1218
 
    ProcessAnEvent ();
1219
 
 
1220
 
    if (acd.accepted)
1221
 
    {
1222
 
      for (vnp = vep->errorfilter, i = 0; vnp != NULL; vnp = vnp->next, i++)
 
1178
static BioseqPtr GetFirstBioseqInSeqEntry (SeqEntryPtr sep)
 
1179
{
 
1180
  BioseqPtr    bsp = NULL;
 
1181
  BioseqSetPtr bssp;
 
1182
  
 
1183
  if (sep == NULL || sep->data.ptrvalue == NULL)
 
1184
  {
 
1185
    return NULL;
 
1186
  }
 
1187
  else if (IS_Bioseq (sep))
 
1188
  {
 
1189
    bsp = sep->data.ptrvalue;
 
1190
  }
 
1191
  else if (IS_Bioseq_set (sep))
 
1192
  {
 
1193
    bssp = (BioseqSetPtr) sep->data.ptrvalue;
 
1194
    for (sep = bssp->seq_set; sep != NULL && bsp == NULL; sep = sep->next)
 
1195
    {
 
1196
      bsp = GetFirstBioseqInSeqEntry (sep);
 
1197
    }
 
1198
  }
 
1199
  return bsp;
 
1200
}
 
1201
 
 
1202
 
 
1203
static BioseqPtr GetBioseqForDescriptor (ObjValNodePtr ovp)
 
1204
{
 
1205
  BioseqPtr    bsp = NULL;
 
1206
  BioseqSetPtr bssp;
 
1207
  SeqEntryPtr  sep;
 
1208
  
 
1209
  if (ovp == NULL || ovp->idx.parentptr == NULL)
 
1210
  {
 
1211
    return NULL;
 
1212
  }
 
1213
  else if (ovp->idx.parenttype == OBJ_BIOSEQ) {
 
1214
    bsp = (BioseqPtr) ovp->idx.parentptr;
 
1215
  } else if (ovp->idx.parenttype == OBJ_BIOSEQSET) {
 
1216
    bssp = (BioseqSetPtr) ovp->idx.parentptr;
 
1217
    for (sep = bssp->seq_set; sep != NULL && bsp == NULL; sep = sep->next)
 
1218
    {
 
1219
      bsp = GetFirstBioseqInSeqEntry (sep);
 
1220
    }  
 
1221
  }
 
1222
  return bsp;
 
1223
}
 
1224
 
 
1225
 
 
1226
static BioseqPtr GetBioseqFromErrItem (ErrItemPtr eip)
 
1227
{
 
1228
  BioseqPtr  bsp = NULL;
 
1229
  SeqFeatPtr sfp;
 
1230
  SeqDescrPtr sdp;
 
1231
  ObjValNodePtr ovp;
 
1232
  SeqMgrDescContext context;
 
1233
 
 
1234
  if (eip == NULL) {
 
1235
    return NULL;
 
1236
  }
 
1237
  switch (eip->itemtype) {
 
1238
    case OBJ_BIOSEQ:
 
1239
      bsp = GetBioseqGivenIDs (eip->entityID, eip->itemID, eip->itemtype);
 
1240
      break;
 
1241
    case OBJ_SEQFEAT:
 
1242
      sfp = GetSeqFeatGivenIDs (eip->entityID, eip->itemID, eip->itemtype);
 
1243
      if (sfp != NULL)
1223
1244
      {
1224
 
        if (vnp->data.ptrvalue != NULL && GetStatus (btn_array[i])) 
1225
 
        {
1226
 
          ValNodeAddPointer (&chosen, 0, vnp->data.ptrvalue);
1227
 
        }
1228
 
      }
1229
 
    }
 
1245
        bsp = BioseqFindFromSeqLoc (sfp->location);
 
1246
      }
 
1247
      break;
 
1248
    case OBJ_SEQDESC:
 
1249
      sdp = SeqMgrGetDesiredDescriptor (eip->entityID, NULL, eip->itemID, 0, NULL, &context);
 
1250
      if (sdp != NULL && sdp->extended != 0) {
 
1251
        ovp = (ObjValNodePtr) sdp;
 
1252
        bsp = GetBioseqForDescriptor (ovp);
 
1253
      }
 
1254
      break;
1230
1255
  }
1231
 
  btn_array = MemFree (btn_array);
1232
 
  Remove (w);
1233
 
  return chosen;
 
1256
  return bsp;
1234
1257
}
1235
1258
 
1236
1259
 
1255
1278
}
1256
1279
 
1257
1280
 
 
1281
static int LIBCALLBACK SortVnpByChoiceAndPtrvalue (VoidPtr ptr1, VoidPtr ptr2)
 
1282
 
 
1283
{
 
1284
  ValNodePtr  vnp1;
 
1285
  ValNodePtr  vnp2;
 
1286
 
 
1287
  if (ptr1 == NULL || ptr2 == NULL) return 0;
 
1288
  vnp1 = *((ValNodePtr PNTR) ptr1);
 
1289
  vnp2 = *((ValNodePtr PNTR) ptr2);
 
1290
  if (vnp1 == NULL || vnp2 == NULL) return 0;
 
1291
 
 
1292
  if (vnp1->choice > vnp2->choice) {
 
1293
    return 1;
 
1294
  } else if (vnp1->choice < vnp2->choice) {
 
1295
    return -1;
 
1296
  } else if (vnp1->data.ptrvalue > vnp2->data.ptrvalue) {
 
1297
    return 1;
 
1298
  } else if (vnp1->data.ptrvalue < vnp2->data.ptrvalue) {
 
1299
    return -1;
 
1300
  } else {
 
1301
    return 0;
 
1302
  }
 
1303
}
 
1304
 
 
1305
 
 
1306
static ValNodePtr CollectBioseqsByValidatorReportTypes (ValidExtraPtr vep)
 
1307
{
 
1308
  ErrFltrPtr  efp;
 
1309
  ErrItemPtr  eip;
 
1310
  ValNodePtr  chosen = NULL, vnp, bsp_list = NULL;
 
1311
  WindoW      w, h, btn_grp, g1 = NULL, c;
 
1312
  Int4        num_buttons, i;
 
1313
  ValidatorReportTypeData data;
 
1314
  ButtoN PNTR btn_array;
 
1315
  ButtoN      b;
 
1316
  int         last_errcode = 0;
 
1317
  ModalAcceptCancelData acd;
 
1318
  Int4        pos;
 
1319
  BioseqPtr   bsp;
 
1320
  
 
1321
  if (vep == NULL || vep->errorfilter == NULL) return NULL;
 
1322
 
 
1323
  /* if only one, just select the one */
 
1324
  if (vep->errorfilter->next == NULL) 
 
1325
  {
 
1326
    ValNodeAddPointer (&chosen, 0, vep->errorfilter->data.ptrvalue);
 
1327
    return chosen;
 
1328
  }
 
1329
 
 
1330
  num_buttons = ValNodeLen (vep->errorfilter);
 
1331
  btn_array = (ButtoN PNTR) MemNew (sizeof (ButtoN) * num_buttons);
 
1332
 
 
1333
  data.btn_array = btn_array;
 
1334
  data.errorfilter = vep->errorfilter;
 
1335
 
 
1336
  w = MovableModalWindow (-50, -33, -10, -10, "Choose Report Items", NULL);
 
1337
  SetGroupSpacing (w, 10, 10);
 
1338
  h = HiddenGroup (w, -1, 0, NULL);
 
1339
  SetGroupSpacing (h, 10, 10);
 
1340
 
 
1341
  btn_grp = HiddenGroup (h, 3, 0, NULL);
 
1342
  for (vnp = vep->errorfilter, i = 0; vnp != NULL; vnp = vnp->next, i++) {
 
1343
    efp = (ErrFltrPtr) vnp->data.ptrvalue;
 
1344
    if (efp == NULL) continue;
 
1345
    if (efp->subcode == INT_MIN) {
 
1346
      g1 = NormalGroup (btn_grp, 0, 10, efp->text2, programFont, NULL);
 
1347
      btn_array[i] = CheckBox (g1, "All", EnableValidatorReportTypeButtons);
 
1348
      SetObjectExtra (btn_array[i], &data, NULL);
 
1349
      last_errcode = efp->errcode;
 
1350
    } else {
 
1351
      if (last_errcode != efp->errcode) {
 
1352
        g1 = NULL;
 
1353
      }
 
1354
      btn_array[i] = CheckBox (g1 == NULL ? btn_grp : g1, efp->text3 == NULL ? "" : efp->text3, NULL);
 
1355
    }
 
1356
  }
 
1357
 
 
1358
  c = HiddenGroup (w, 4, 0, NULL);
 
1359
  SetGroupSpacing (c, 10, 2);
 
1360
  b = DefaultButton (c, "Accept", ModalAcceptButton);
 
1361
  SetObjectExtra (b, &acd, NULL);
 
1362
  b = PushButton (c, "Cancel", ModalCancelButton);
 
1363
  SetObjectExtra (b, &acd, NULL);
 
1364
 
 
1365
  AlignObjects (ALIGN_CENTER, (HANDLE) btn_grp, (HANDLE) c, NULL);
 
1366
  RealizeWindow (w);
 
1367
 
 
1368
  Show (w);
 
1369
  Select (w);
 
1370
  Update ();
 
1371
 
 
1372
  acd.accepted = FALSE;
 
1373
  acd.cancelled = FALSE;
 
1374
  
 
1375
  while (!acd.accepted && ! acd.cancelled)
 
1376
  {
 
1377
    while (!acd.accepted && ! acd.cancelled)
 
1378
    {
 
1379
      ProcessExternalEvent ();
 
1380
      Update ();
 
1381
    }
 
1382
    ProcessAnEvent ();
 
1383
 
 
1384
    if (acd.accepted)
 
1385
    {
 
1386
      for (vnp = vep->errorfilter, i = 0; vnp != NULL; vnp = vnp->next, i++)
 
1387
      {
 
1388
        if (vnp->data.ptrvalue != NULL && GetStatus (btn_array[i])) 
 
1389
        {
 
1390
          /* add ErrorFilterPtr to list of categories */
 
1391
          ValNodeAddPointer (&chosen, 0, vnp->data.ptrvalue);
 
1392
        }
 
1393
      }
 
1394
    }
 
1395
  }
 
1396
  btn_array = MemFree (btn_array);
 
1397
 
 
1398
  for (vnp = vep->messages; vnp != NULL; vnp = vnp->next) {
 
1399
    eip = (ErrItemPtr) vnp->data.ptrvalue;
 
1400
    if (eip != NULL) {
 
1401
      pos = FindReportPositionForError (eip, chosen);
 
1402
      if (pos != -1) {
 
1403
        bsp = GetBioseqFromErrItem (eip);
 
1404
        ValNodeAddPointer (&bsp_list, OBJ_BIOSEQ, bsp);
 
1405
      }
 
1406
    }
 
1407
  }
 
1408
  chosen = ValNodeFree (chosen);
 
1409
 
 
1410
  bsp_list = ValNodeSort (bsp_list, SortVnpByChoiceAndPtrvalue);
 
1411
  ValNodeUnique (&bsp_list, SortVnpByChoiceAndPtrvalue, ValNodeFree);
 
1412
 
 
1413
  Remove (w);
 
1414
  return bsp_list;
 
1415
}
 
1416
 
 
1417
 
 
1418
static ValNodePtr CollectValidatorReportTypes (ValidExtraPtr vep)
 
1419
{
 
1420
  ErrFltrPtr  efp;
 
1421
  ValNodePtr  chosen = NULL, vnp;
 
1422
  WindoW      w, h, btn_grp, g1 = NULL, c;
 
1423
  Int4        num_buttons, i;
 
1424
  ValidatorReportTypeData data;
 
1425
  ButtoN PNTR btn_array;
 
1426
  ButtoN      b;
 
1427
  int         last_errcode = 0;
 
1428
  ModalAcceptCancelData acd;
 
1429
  
 
1430
  if (vep == NULL || vep->errorfilter == NULL) return NULL;
 
1431
 
 
1432
  /* if only one, just select the one */
 
1433
  if (vep->errorfilter->next == NULL) 
 
1434
  {
 
1435
    ValNodeAddPointer (&chosen, 0, vep->errorfilter->data.ptrvalue);
 
1436
    return chosen;
 
1437
  }
 
1438
 
 
1439
  num_buttons = ValNodeLen (vep->errorfilter);
 
1440
  btn_array = (ButtoN PNTR) MemNew (sizeof (ButtoN) * num_buttons);
 
1441
 
 
1442
  data.btn_array = btn_array;
 
1443
  data.errorfilter = vep->errorfilter;
 
1444
 
 
1445
  w = MovableModalWindow (-50, -33, -10, -10, "Choose Report Items", NULL);
 
1446
  SetGroupSpacing (w, 10, 10);
 
1447
  h = HiddenGroup (w, -1, 0, NULL);
 
1448
  SetGroupSpacing (h, 10, 10);
 
1449
 
 
1450
  btn_grp = HiddenGroup (h, 3, 0, NULL);
 
1451
  for (vnp = vep->errorfilter, i = 0; vnp != NULL; vnp = vnp->next, i++) {
 
1452
    efp = (ErrFltrPtr) vnp->data.ptrvalue;
 
1453
    if (efp == NULL) continue;
 
1454
    if (efp->subcode == INT_MIN) {
 
1455
      g1 = NormalGroup (btn_grp, 0, 10, efp->text2, programFont, NULL);
 
1456
      btn_array[i] = CheckBox (g1, "All", EnableValidatorReportTypeButtons);
 
1457
      SetObjectExtra (btn_array[i], &data, NULL);
 
1458
      last_errcode = efp->errcode;
 
1459
    } else {
 
1460
      if (last_errcode != efp->errcode) {
 
1461
        g1 = NULL;
 
1462
      }
 
1463
      btn_array[i] = CheckBox (g1 == NULL ? btn_grp : g1, efp->text3 == NULL ? "" : efp->text3, NULL);
 
1464
    }
 
1465
  }
 
1466
 
 
1467
  c = HiddenGroup (w, 4, 0, NULL);
 
1468
  SetGroupSpacing (c, 10, 2);
 
1469
  b = DefaultButton (c, "Accept", ModalAcceptButton);
 
1470
  SetObjectExtra (b, &acd, NULL);
 
1471
  b = PushButton (c, "Cancel", ModalCancelButton);
 
1472
  SetObjectExtra (b, &acd, NULL);
 
1473
 
 
1474
  AlignObjects (ALIGN_CENTER, (HANDLE) btn_grp, (HANDLE) c, NULL);
 
1475
  RealizeWindow (w);
 
1476
 
 
1477
  Show (w);
 
1478
  Select (w);
 
1479
  Update ();
 
1480
 
 
1481
  acd.accepted = FALSE;
 
1482
  acd.cancelled = FALSE;
 
1483
  
 
1484
  while (!acd.accepted && ! acd.cancelled)
 
1485
  {
 
1486
    while (!acd.accepted && ! acd.cancelled)
 
1487
    {
 
1488
      ProcessExternalEvent ();
 
1489
      Update ();
 
1490
    }
 
1491
    ProcessAnEvent ();
 
1492
 
 
1493
    if (acd.accepted)
 
1494
    {
 
1495
      for (vnp = vep->errorfilter, i = 0; vnp != NULL; vnp = vnp->next, i++)
 
1496
      {
 
1497
        if (vnp->data.ptrvalue != NULL && GetStatus (btn_array[i])) 
 
1498
        {
 
1499
          ValNodeAddPointer (&chosen, 0, vnp->data.ptrvalue);
 
1500
        }
 
1501
      }
 
1502
    }
 
1503
  }
 
1504
  btn_array = MemFree (btn_array);
 
1505
  Remove (w);
 
1506
  return chosen;
 
1507
}
 
1508
 
 
1509
 
1258
1510
static Boolean MakeStandardReports (ValNodePtr chosen, ValNodePtr PNTR reports_list, FILE *fp)
1259
1511
{
1260
1512
  ValNodePtr chosen_vnp, item_vnp;
1456
1708
}
1457
1709
 
1458
1710
 
 
1711
static void SequesterByValidatorErrors (ButtoN b)
 
1712
{
 
1713
  ValidExtraPtr  vep;
 
1714
  ValNodePtr     bsp_list;
 
1715
  BioseqPtr      bsp;
 
1716
  Uint2          entityID = 0;
 
1717
 
 
1718
  vep = (ValidExtraPtr) GetObjectExtra (b);
 
1719
  if (vep == NULL || vep->sequesterProc == NULL) return;
 
1720
  bsp_list = CollectBioseqsByValidatorReportTypes (vep);
 
1721
  if (bsp_list == NULL) {
 
1722
    Message (MSG_ERROR, "No Bioseqs selected!");
 
1723
    return;
 
1724
  }
 
1725
  if (bsp_list->choice == OBJ_BIOSEQ && bsp_list->data.ptrvalue != NULL) {
 
1726
    bsp = (BioseqPtr) bsp_list->data.ptrvalue;
 
1727
    entityID = bsp->idx.entityID;
 
1728
  }
 
1729
 
 
1730
  (vep->sequesterProc) (entityID, bsp_list);
 
1731
  bsp_list = ValNodeFree (bsp_list);
 
1732
}
 
1733
 
 
1734
 
1459
1735
static Boolean ValExportProc (ForM f, CharPtr filename)
1460
1736
 
1461
1737
{
1646
1922
  }
1647
1923
}
1648
1924
 
 
1925
 
 
1926
static void ContinueProc (ButtoN b)
 
1927
 
 
1928
{
 
1929
  BaseFormPtr    bfp;
 
1930
  int            i;
 
1931
  ValidExtraPtr  vep;
 
1932
 
 
1933
  vep = GetObjectExtra (b);
 
1934
  if (vep != NULL) {
 
1935
    for (i = SEV_NONE; i <= SEV_MAX; i++) {
 
1936
      vep->counts [i] = 0;
 
1937
    }
 
1938
    vep->totalcount = 0;
 
1939
    vep->addedcount = 0;
 
1940
    vep->remaining = 0;
 
1941
    vep->clicked = 0;
 
1942
    vep->selected = 0;
 
1943
    vep->dblClick = FALSE;
 
1944
    bfp = vep->bfp;
 
1945
    if (bfp != NULL && vep->continueProc != NULL) {
 
1946
      vep->continueProc (bfp->form);
 
1947
    }
 
1948
  }
 
1949
}
 
1950
 
 
1951
 
1649
1952
static void SetVerbosityAndRepopulate (PopuP p)
1650
1953
 
1651
1954
{
1833
2136
"Double click on an error item to launch the appropriate feature editor.";
1834
2137
 
1835
2138
/* CreateValidateWindowEx is hidden, allowing a revalidate button */
1836
 
extern WindoW CreateValidateWindowEx (ErrNotifyProc notify, CharPtr title,
 
2139
extern WindoW CreateValidateWindowExExEx (ErrNotifyProc notify, CharPtr title,
1837
2140
                                    FonT font, ErrSev sev, Int2 verbose,
1838
 
                                    BaseFormPtr bfp, FormActnFunc revalProc,
 
2141
                                    BaseFormPtr bfp, FormActnFunc revalProc, FormActnFunc continueProc,
 
2142
                                    SequesterProc sequesterProc,
1839
2143
                                    Boolean okaytosetviewtarget)
1840
2144
 
1841
2145
{
1885
2189
 
1886
2190
        ppt = MultiLinePrompt (w, canStillSubmitText, stdCharWidth * 30, systemFont);
1887
2191
 
1888
 
        c = HiddenGroup (w, 8, 0, NULL);
 
2192
        c = HiddenGroup (w, 9, 0, NULL);
1889
2193
        SetGroupSpacing (c, 10, 2);
1890
2194
        /*
1891
2195
        vep->remove = PushButton (c, "Remove", RemoveProc);
1926
2230
        } else {
1927
2231
          SetValue (vep->minlevel, 1);
1928
2232
        }
 
2233
        /* set up revalidate button */
1929
2234
        vep->revalBtn = PushButton (c, "Revalidate", RevalidateProc);
1930
2235
        SetObjectExtra (vep->revalBtn, vep, NULL);
1931
2236
        Hide (vep->revalBtn);
 
2237
 
 
2238
        /* set up continue button */
 
2239
        vep->continueBtn = PushButton (c, "Done", ContinueProc);
 
2240
        SetObjectExtra (vep->continueBtn, vep, NULL);
 
2241
        Hide (vep->revalBtn);
 
2242
 
1932
2243
        /*
1933
2244
        Advance (w);
1934
2245
        */
1994
2305
 
1995
2306
        vep->summary = StaticPrompt (w, "", stdCharWidth * 30, 0, systemFont, 'c');
1996
2307
 
1997
 
        btn_grp = HiddenGroup (w, 2, 0, NULL);
 
2308
        btn_grp = HiddenGroup (w, 3, 0, NULL);
1998
2309
        SetGroupSpacing (btn_grp, 10, 10);
1999
2310
        if (indexerVersion) {
2000
2311
          b = PushButton (btn_grp, "Report", MakeValidatorReport);
2001
2312
          SetObjectExtra (b, vep, NULL);
 
2313
          if (sequesterProc != NULL) {
 
2314
            vep->sequesterProc = sequesterProc;
 
2315
            b = PushButton (btn_grp, "Sequester", SequesterByValidatorErrors);
 
2316
            SetObjectExtra (b, vep, NULL);
 
2317
          }
2002
2318
        }
2003
2319
 
2004
2320
        b = PushButton (btn_grp, "Dismiss", CloseValidButton);
2023
2339
      } else {
2024
2340
        SafeHide (vep->revalBtn);
2025
2341
      }
 
2342
      vep->continueProc = continueProc;
 
2343
      if (vep->continueProc != NULL) {
 
2344
        SafeShow (vep->continueBtn);
 
2345
      } else {
 
2346
        SafeHide (vep->continueBtn);
 
2347
      }
2026
2348
      vep->okaytosetviewtarget = okaytosetviewtarget;
2027
2349
    }
2028
2350
  }
2029
2351
  return validWindow;
2030
2352
}
2031
2353
 
 
2354
extern WindoW CreateValidateWindowExEx (ErrNotifyProc notify, CharPtr title,
 
2355
                                    FonT font, ErrSev sev, Int2 verbose,
 
2356
                                    BaseFormPtr bfp, FormActnFunc revalProc, FormActnFunc continueProc,
 
2357
                                    Boolean okaytosetviewtarget)
 
2358
{
 
2359
  return CreateValidateWindowExExEx (notify, title,
 
2360
                                    font, sev, verbose,
 
2361
                                    bfp, revalProc, continueProc,
 
2362
                                    NULL,
 
2363
                                    okaytosetviewtarget);
 
2364
}
 
2365
 
 
2366
extern WindoW CreateValidateWindowEx (ErrNotifyProc notify, CharPtr title,
 
2367
                                    FonT font, ErrSev sev, Int2 verbose,
 
2368
                                    BaseFormPtr bfp, FormActnFunc revalProc,
 
2369
                                    Boolean okaytosetviewtarget)
 
2370
{
 
2371
  return CreateValidateWindowExEx (notify, title, font, sev, verbose, bfp, revalProc, NULL, okaytosetviewtarget);
 
2372
}
 
2373
 
2032
2374
extern WindoW CreateValidateWindow (ErrNotifyProc notify, CharPtr title,
2033
2375
                                  FonT font, ErrSev sev, Int2 verbose)
2034
2376
 
2384
2726
  Uint2 itemtype,
2385
2727
  Uint4 itemID,
2386
2728
  CharPtr accession,
 
2729
  CharPtr featureID,
2387
2730
  CharPtr message,
2388
2731
  CharPtr objtype,
2389
2732
  CharPtr label,
2475
2818
  eip->catname = StringSaveNoNull (catname);
2476
2819
  eip->errname = StringSaveNoNull (errname);
2477
2820
  eip->accession = StringSaveNoNull (accession);
 
2821
  eip->featureID = StringSaveNoNull (featureID);
2478
2822
  eip->message = StringSaveNoNull (message);
2479
2823
  eip->objtype = StringSaveNoNull (objtype);
2480
2824
  eip->label = StringSaveNoNull (label);