~ubuntu-branches/ubuntu/oneiric/ncbi-tools6/oneiric

static DialoG CreateRNATranscriptIDDialog (GrouP h, Uint2 entityID, Boolean allow_far_id, Nlm_ChangeNotifyProc change_notify, Pointer change_userdata)

1650

{

1651

GrouP p;

1652

RnaTranscriptIdDlgPtr dlg;

1653

ValNodePtr bsp_list = NULL;

1654

1655

p = HiddenGroup (h, 3, 0, NULL);

1656

SetGroupSpacing (p, 10, 10);

1657

1658

dlg = (RnaTranscriptIdDlgPtr) MemNew (sizeof (RnaTranscriptIDDlgData));

1659

if (dlg == NULL) return NULL;

1660

1661

SetObjectExtra (p, dlg, StdCleanupExtraProc);

1662

dlg->dialog = (DialoG) p;

1663

dlg->todialog = LocToTranscriptIDDialog;

1664

dlg->fromdialog = TranscriptIDDialogToLoc;

1665

1666

dlg->change_notify = change_notify;

1667

dlg->change_userdata = change_userdata;

1668

1669

StaticPrompt (p, "Transcript Sequence ID", 0, popupMenuHeight, programFont, 'l');

1670

dlg->product = SequenceSelectionDialogEx (p, ChangeTranscriptIDSequenceSelection, dlg, FALSE, TRUE, TRUE, FALSE, entityID, SHORT_SELECTION_LIST);

1671

if (allow_far_id)

1672

{

1673

dlg->far_id_grp = HiddenGroup (p, 2, 0, NULL);

1674

StaticPrompt (dlg->far_id_grp, "Far ID", 0, dialogTextHeight, programFont, 'l');

1675

dlg->far_id = DialogText (dlg->far_id_grp, "", 5, ChangeTranscriptIDText);

1676

SetObjectExtra (dlg->far_id, dlg, NULL);

1677

}

1678

1679

return (DialoG) p;

1680

}

1681

1682

1499

1683

extern SeqLocPtr PredictCodingRegion (BioseqPtr nuc, BioseqPtr prot, Int2 genCode)

1500

1684

1501

1685

{

1658

1842

bsp->repr = Seq_repr_raw;

1659

1843

bsp->mol = Seq_mol_aa;

1660

1844

bsp->seq_data_type = Seq_code_ncbieaa;

1661

bsp->seq_data = bs;

1845

bsp->seq_data = (SeqDataPtr) bs;

1662

1846

bsp->length = BSLen (bs);

1663

1847

PointerToDialog (cfp->protseq, bsp);

1664

1848

SetProteinLengthDisplay (cfp->protlen, bsp->length - star_at_end);

2243

2427

}

2244

2428

2245

2429

2430

static CharPtr GetProteinString (CdRgnFormPtr cfp, SeqLocPtr location)

2431

{

2432

SeqFeatPtr sfp;

2433

ByteStorePtr bs;

2434

CharPtr prot = NULL;

2435

2436

if (cfp == NULL || location == NULL) return NULL;

2437

sfp = SeqFeatNew ();

2438

if (sfp == NULL) return NULL;

2439

2440

sfp->data.choice = SEQFEAT_CDREGION;

2441

sfp->data.value.ptrvalue = DialogToPointer (cfp->data);

2442

sfp->location = location;

2443

bs = ProteinFromCdRegionEx (sfp, TRUE, FALSE);

2444

if (bs != NULL) {

2445

prot = BSMerge (bs, NULL);

2446

bs = BSFree (bs);

2447

}

2448

/* IMPORTANT - do not free the location that was passed in */

2449

sfp->location = NULL;

2450

SeqFeatFree (sfp);

2451

return prot;

2452

}

2453

2454

2455

extern SeqLocPtr TruncateLocation (SeqLocPtr head, Int4 len)

2456

{

2457

SeqLocPtr slp = NULL;

2458

SeqIdPtr sip;

2459

Int4 from = 0, to = 0;

2460

Boolean changed = FALSE;

2461

Int4 loc_len = 0;

2462

Int4 cum_len = 0;

2463

SeqLocPtr del_slp;

2464

ValNodePtr del_slp_list = NULL, vnp;

2465

Uint1 strand;

2466

2467

if (head == NULL || len < 1)

2468

return head;

2469

2470

slp = SeqLocFindNext (head, slp);

2471

while (slp != NULL)

2472

{

2473

if (cum_len >= len)

2474

{

2475

del_slp = AsnIoMemCopy(slp,

2476

(AsnReadFunc) SeqLocAsnRead, (AsnWriteFunc) SeqLocAsnWrite);

2477

ValNodeAddPointer (&del_slp_list, 0, del_slp);

2478

}

2479

else

2480

{

2481

sip = SeqLocId(slp);

2482

from = SeqLocStart(slp);

2483

to = SeqLocStop(slp);

2484

loc_len = (to - from + 1);

2485

cum_len += loc_len;

2486

if (cum_len > len)

2487

{

2488

strand = SeqLocStrand (slp);

2489

/* remove part of this location */

2490

if (strand == Seq_strand_minus)

2491

{

2492

to = cum_len - len + from - 1;

2493

}

2494

else

2495

{

2496

from = to - (cum_len - len) + 1;

2497

}

2498

del_slp = SeqLocIntNew (from, to, strand, sip);

2499

ValNodeAddPointer (&del_slp_list, 0, del_slp);

2500

}

2501

}

2502

slp = SeqLocFindNext (head, slp);

2503

}

2504

2505

for (vnp = del_slp_list; vnp != NULL; vnp = vnp->next)

2506

{

2507

slp = (SeqLocPtr) vnp->data.ptrvalue;

2508

if (slp == NULL) continue;

2509

sip = SeqLocId(slp);

2510

from = SeqLocStart(slp);

2511

to = SeqLocStop(slp);

2512

head = SeqLocDelete(head, sip, from, to, FALSE, &changed);

2513

}

2514

2515

return head;

2516

}

2517

2518

2519

static Boolean LengthenLocation (SeqLocPtr head, Int4 len)

2520

{

2521

SeqLocPtr slp = NULL, last_slp = NULL;

2522

SeqIntPtr sintp;

2523

SeqPntPtr spp;

2524

Int4 orig_len, len_diff;

2525

Boolean rval = FALSE;

2526

BioseqPtr bsp;

2527

2528

if (head == NULL || len < 1)

2529

return FALSE;

2530

2531

orig_len = SeqLocLen (head);

2532

len_diff = len - orig_len;

2533

if (len_diff <= 0) return FALSE;

2534

2535

slp = SeqLocFindNext (head, slp);

2536

while (slp != NULL)

2537

{

2538

last_slp = slp;

2539

slp = SeqLocFindNext (head, slp);

2540

}

2541

2542

if (last_slp->choice == SEQLOC_INT) {

2543

sintp = (SeqIntPtr) last_slp->data.ptrvalue;

2544

if (sintp->strand == Seq_strand_minus) {

2545

if (sintp->from - len_diff >= 0) {

2546

sintp->from -= len_diff;

2547

rval = TRUE;

2548

}

2549

} else {

2550

bsp = BioseqFind (sintp->id);

2551

if (bsp != NULL && sintp->to + len_diff < bsp->length) {

2552

sintp->to += len_diff;

2553

rval = TRUE;

2554

}

2555

}

2556

} else if (last_slp->choice == SEQLOC_PNT) {

2557

spp = (SeqPntPtr) last_slp->data.ptrvalue;

2558

rval = TRUE;

2559

if (spp->strand == Seq_strand_minus) {

2560

if (spp->point - len_diff < 0) {

2561

rval = FALSE;

2562

}

2563

} else {

2564

bsp = BioseqFind (spp->id);

2565

if (bsp == NULL || spp->point + len_diff >= bsp->length) {

2566

rval = FALSE;

2567

}

2568

}

2569

if (rval) {

2570

sintp = SeqIntNew ();

2571

sintp->id = SeqIdDup (spp->id);

2572

sintp->strand = spp->strand;

2573

sintp->if_from = AsnIoMemCopy (spp->fuzz, (AsnReadFunc) IntFuzzAsnRead, (AsnWriteFunc) IntFuzzAsnWrite);

2574

sintp->if_from = AsnIoMemCopy (spp->fuzz, (AsnReadFunc) IntFuzzAsnRead, (AsnWriteFunc) IntFuzzAsnWrite);

2575

if (sintp->strand == Seq_strand_minus) {

2576

sintp->from = spp->point - len_diff;

2577

sintp->to = spp->point;

2578

} else {

2579

sintp->from = spp->point;

2580

sintp->to = spp->point + len_diff;

2581

}

2582

spp = SeqPntFree (spp);

2583

last_slp->data.ptrvalue = sintp;

2584

last_slp->choice = SEQLOC_INT;

2585

}

2586

}

2587

2588

return rval;

2589

}

2590

2591

2592

static void AdjustForStopCodon (ButtoN b)

2593

2594

{

2595

CdRgnFormPtr cfp;

2596

SeqLocPtr orig_slp;

2597

BioseqPtr nucBsp;

2598

Boolean partial5, partial3;

2599

Uint1 strand;

2600

CharPtr prot, cp;

2601

Int4 desired_cds_len, loc_len, max_len;

2602

CdRegionPtr crp;

2603

Uint1 frame = 0;

2604

2605

cfp = (CdRgnFormPtr) GetObjectExtra (b);

2606

if (cfp == NULL) {

2607

return;

2608

}

2609

2610

orig_slp = DialogToPointer (cfp->location);

2611

if (orig_slp == NULL) {

2612

Message (MSG_ERROR, "No location to adjust!");

2613

return;

2614

}

2615

2616

CheckSeqLocForPartial (orig_slp, &partial5, &partial3);

2617

2618

nucBsp = GetBioseqGivenSeqLoc (orig_slp, cfp->input_entityID);

2619

if (nucBsp == NULL) {

2620

Message (MSG_ERROR, "Unable to find Bioseq for coding region location");

2621

orig_slp = SeqLocFree (orig_slp);

2622

return;

2623

}

2624

2625

crp = DialogToPointer (cfp->data);

2626

if (crp != NULL) {

2627

frame = crp->frame;

2628

if (frame > 0) {

2629

frame--;

2630

}

2631

crp = CdRegionFree (crp);

2632

}

2633

2634

prot = GetProteinString (cfp, orig_slp);

2635

if (StringHasNoText (prot)) {

2636

Message (MSG_ERROR, "Translation failed");

2637

prot = MemFree (prot);

2638

orig_slp = SeqLocFree (orig_slp);

2639

return;

2640

}

2641

2642

cp = StringChr (prot, '*');

2643

2644

if (cp == NULL) {

2645

/* lengthen coding region, look for stop codon */

2646

strand = SeqLocStrand (orig_slp);

2647

loc_len = SeqLocLen (orig_slp);

2648

if (strand == Seq_strand_minus) {

2649

max_len = loc_len + SeqLocStart (orig_slp);

2650

} else {

2651

max_len = loc_len + nucBsp->length - SeqLocStop (orig_slp) - 1;

2652

}

2653

2654

if (LengthenLocation (orig_slp, max_len)) {

2655

prot = MemFree (prot);

2656

prot = GetProteinString (cfp, orig_slp);

2657

cp = StringChr (prot, '*');

2658

if (cp == NULL) {

2659

if (ANS_YES == Message (MSG_YN, "No stop codon found - extend to full length of sequence (and make partial)?")) {

2660

SetSeqLocPartial (orig_slp, partial5, TRUE);

2661

PointerToDialog (cfp->location, orig_slp);

2662

DoTranslateProtein (cfp);

2663

}

2664

prot = MemFree (prot);

2665

orig_slp = SeqLocFree (orig_slp);

2666

return;

2667

}

2668

} else {

2669

Message (MSG_ERROR, "Unable to lengthen location!");

2670

prot = MemFree (prot);

2671

orig_slp = SeqLocFree (orig_slp);

2672

return;

2673

}

2674

}

2675

2676

desired_cds_len = ((cp - prot) + 1) * 3;

2677

if (frame > 0) {

2678

desired_cds_len += frame;

2679

}

2680

2681

loc_len = SeqLocLen (orig_slp);

2682

if (desired_cds_len < loc_len) {

2683

/* truncate to correct length */

2684

orig_slp = TruncateLocation (orig_slp, desired_cds_len);

2685

PointerToDialog (cfp->location, orig_slp);

2686

DoTranslateProtein (cfp);

2687

}

2688

prot = MemFree (prot);

2689

orig_slp = SeqLocFree (orig_slp);

2690

}

2691

2692

2693

static SeqEntryPtr GetSeqEntryForLocation (SeqLocPtr slp, Uint2 entityID)

2694

{

2695

BioseqPtr bsp;

2696

2697

if (slp == NULL)

2698

{

2699

return GetTopSeqEntryForEntityID (entityID);

2700

}

2701

2702

bsp = BioseqFindFromSeqLoc (slp);

2703

if (bsp == NULL)

2704

{

2705

return GetTopSeqEntryForEntityID (entityID);

2706

}

2707

2708

return GetBestTopParentForData (entityID, bsp);

2709

}

2710

2711

2712

static void SetCdRegionPageGeneticCode (DialoG d)

2713

{

2714

CdRgnPagePtr cpp;

2715

SeqLocPtr slp;

2716

Int2 genCode;

2717

2718

cpp = (CdRgnPagePtr) GetObjectExtra (d);

2719

if (cpp != NULL) {

2720

slp = DialogToPointer (cpp->cfp->location);

2721

genCode = SeqEntryToGeneticCode (GetSeqEntryForLocation (slp, cpp->cfp->input_entityID), NULL, NULL, 0);

2722

slp = SeqLocFree (slp);

2723

SetValue (cpp->geneticCode, gcIdToIndex [genCode]);

2724

}

2725

}

2726

2727

2246

2728

static DialoG CreateCdRgnDialog (GrouP h, CharPtr title, Int2 genCode,

2247

2729

SeqFeatPtr sfp, CdRgnFormPtr cfp)

2248

2730

2329

2811

cfp->protseq = CreateBioseqRawDialog (x, NULL, Seq_mol_aa, cfp);

2330

2812

cfp->usethisbioseq = NULL;

2331

2813

2332

c = HiddenGroup (g, 4, 0, NULL);

2814

c = HiddenGroup (g, 3, 0, NULL);

2333

2815

b = PushButton (c, "Predict Interval", PredictCdRegion);

2334

2816

SetObjectExtra (b, cfp, NULL);

2335

2817

b = PushButton (c, "Translate Product", TranslateProtein);

2343

2825

/* add switch to protein button only if indexer version */

2344

2826

if (GetAppProperty ("InternalNcbiSequin") != NULL)

2345

2827

{

2346

cfp->edProtBtn2 = PushButton (g, "Switch to Protein Feature Editor", SwitchToProtFeatEd);

2828

cfp->edProtBtn2 = PushButton (c, "Switch to Protein Feature Editor", SwitchToProtFeatEd);

2347

2829

SetObjectExtra (cfp->edProtBtn2, cfp, NULL);

2348

2830

Disable (cfp->edProtBtn2);

2349

2831

}

2832

b = PushButton (c, "Adjust for Stop Codon", AdjustForStopCodon);

2833

SetObjectExtra (b, cfp, NULL);

2350

2834

2351

2835

AlignObjects (ALIGN_CENTER, (HANDLE) x, (HANDLE) c, (HANDLE) y, NULL);

2352

2836

2364

2848

"Press Edit Protein Feature to change protein name",

2365

2849

0, 0, programFont, 'l');

2366

2850

Hide (cfp->protPromptGrp);

2851

2852

cfp->makemRNAMatch = CheckBox (cfp->protTextGrp, "Make overlapping mRNA product match protein name", NULL);

2853

Hide (cfp->makemRNAMatch);

2854

AlignObjects (ALIGN_CENTER, (HANDLE) x, (HANDLE) cfp->makemRNAMatch, NULL);

2855

2367

2856

z = HiddenGroup (cpp->cdRgnGrp [1], 3, 0, NULL);

2368

2857

cfp->edProtBtn = PushButton (z, "Edit Protein Feature", LaunchProtFeatEd);

2369

2858

SetObjectExtra (cfp->edProtBtn, cfp, NULL);

2769

3258

sip = SeqLocId (slp);

2770

3259

target = BioseqFind (sip);

2771

3260

if (target != NULL) {

2772

if (!SeqEdFixProteinFeatures (target, newprot, FALSE))

3261

if (!SeqEdFixProteinFeatures (target, newprot, FALSE, Sequin_GlobalAlign2Seq))

2773

3262

{

2774

3263

if (ANS_CANCEL == Message (MSG_OKC, "Unable to construct alignment between old and new proteins.\nYou will need to adjust the protein features manually if you continue."))

2775

3264

{

2924

3413

2925

3414

if (pseudo)

2926

3415

{

3416

Hide (w);

2927

3417

/* remove old product, if there is one */

2928

3418

prod_slp = DialogToPointer (cfp->product);

2929

3419

if (prod_slp != NULL)

3202

3692

vnp->data.ptrvalue = SaveStringFromText (cfp->protNameText);

3203

3693

}

3204

3694

}

3695

3205

3696

prp->desc = MemFree (prp->desc);

3206

3697

prp->desc = SaveStringFromText (cfp->protDescText);

3207

3698

return TRUE;

3324

3815

GBQualPtr quals;

3325

3816

SeqEntryPtr sep;

3326

3817

Uint1 seq_data_type;

3327

SeqFeatPtr sfp;

3818

SeqFeatPtr sfp, mrna;

3328

3819

SeqIdPtr sip;

3329

3820

SeqLocPtr slp;

3330

3821

BioseqPtr target = NULL;

3331

3822

PartialTrio trio;

3332

3823

ValNodePtr vnp, err_list;

3824

SeqMgrFeatContext fcontext;

3825

RnaRefPtr rrp;

3333

3826

3334

3827

cfp = (CdRgnFormPtr) GetObjectExtra (f);

3335

3828

sep = NULL;

3368

3861

DoTranslateProtein (cfp);

3369

3862

}

3370

3863

3864

3865

/* adjust mRNA product name */

3866

if (GetStatus (cfp->makemRNAMatch)) {

3867

mrna = SeqMgrGetOverlappingmRNA (slp, &fcontext);

3868

if (mrna != NULL && mrna->idx.subtype == FEATDEF_mRNA) {

3869

rrp = (RnaRefPtr) mrna->data.value.ptrvalue;

3870

if (rrp == NULL) {

3871

rrp = RnaRefNew();

3872

mrna->data.value.ptrvalue = rrp;

3873

}

3874

rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);

3875

if (TextHasNoText (cfp->protNameText)) {

3876

rrp->ext.choice = 0;

3877

} else {

3878

rrp->ext.choice = 1;

3879

rrp->ext.value.ptrvalue = SaveStringFromText (cfp->protNameText);

3880

}

3881

}

3882

}

3883

3884

3371

3885

CheckSeqLocForPartial (slp, &partial5, &partial3);

3372

3886

SeqLocFree (slp);

3373

3887

partial = GetStatus (cfp->partial);

3402

3916

if (bsp != NULL) {

3403

3917

seq_data_type = target->seq_data_type;

3404

3918

target->length = bsp->length;

3405

target->seq_data = BSFree (target->seq_data);

3919

target->seq_data = SeqDataFree (target->seq_data, target->seq_data_type);

3406

3920

target->seq_data = bsp->seq_data;

3407

3921

target->seq_data_type = bsp->seq_data_type;

3408

3922

bsp->seq_data = NULL;

3435

3949

if (bsp != NULL) {

3436

3950

seq_data_type = target->seq_data_type;

3437

3951

target->length = bsp->length;

3438

target->seq_data = BSFree (target->seq_data);

3952

target->seq_data = SeqDataFree (target->seq_data, target->seq_data_type);

3439

3953

target->seq_data = bsp->seq_data;

3440

3954

target->seq_data_type = bsp->seq_data_type;

3441

3955

bsp->seq_data = NULL;

3587

4101

}

3588

4102

}

3589

4103

4104

4105

static Int4 GuessFrameFromLocation (SeqLocPtr slp, BioseqPtr bsp)

4106

{

4107

Int4 loc_len, loc_start;

4108

Int4 frame = 0;

4109

Uint1 strand;

4110

Boolean partial5, partial3;

4111

4112

if (slp == NULL || bsp == NULL) return 0;

4113

4114

CheckSeqLocForPartial (slp, &partial5, &partial3);

4115

if (!partial5 || partial3) return 0;

4116

4117

strand = SeqLocStrand (slp);

4118

if (strand == Seq_strand_minus)

4119

{

4120

loc_start = SeqLocStop (slp);

4121

}

4122

else

4123

{

4124

loc_start = SeqLocStart (slp);

4125

}

4126

if ((strand == Seq_strand_minus && loc_start == bsp->length -1)

4127

|| (strand != Seq_strand_minus && loc_start == 0))

4128

{

4129

loc_len = SeqLocLen (slp);

4130

frame = 1 + loc_len %3;

4131

}

4132

return frame;

4133

}

4134

4135

3590

4136

extern Int2 LIBCALLBACK CdRgnGenFunc (Pointer data)

3591

4137

3592

4138

{

3599

4145

SeqEntryPtr sep;

3600

4146

SeqFeatPtr sfp;

3601

4147

WindoW w;

4148

CdRgnPagePtr cpp;

4149

Int4 frame = 0;

3602

4150

3603

4151

ompcp = (OMProcControlPtr) data;

3604

4152

sfp = NULL;

3660

4208

} else {

3661

4209

/* restored, but locvisited flag protects against accidental CDS */

3662

4210

SetNewFeatureDefaultInterval ((FeatureFormPtr) cfp);

4211

SetCdRegionPageGeneticCode (cfp->data);

3663

4212

sel = ObjMgrGetSelected ();

3664

4213

if (sel != NULL && sel->next == NULL && sel->entityID == cfp->input_entityID &&

3665

4214

sel->itemID == cfp->input_itemID && sel->itemtype == cfp->input_itemtype) {

3666

4215

if (sel->regiontype == 1 && sel->region != NULL) {

3667

4216

bsp = GetBioseqGivenIDs (cfp->input_entityID, cfp->input_itemID, cfp->input_itemtype);

3668

4217

if (bsp != NULL && GetBioseqGivenSeqLoc ((SeqLocPtr) sel->region, cfp->input_entityID) == bsp) {

4218

cpp = (CdRgnPagePtr) GetObjectExtra (cfp->data);

4219

if (cpp != NULL) {

4220

frame = GuessFrameFromLocation (sel->region, bsp);

4221

SetValue (cpp->frame, frame + 1);

4222

}

3669

4223

DoTranslateProtein (cfp);

3670

4224

}

3671

4225

}

4581

5135

GrouP pages [NUM_PAGES];

4582

5136

DialoG foldertabs;

4583

5137

Int2 currentPage;

5138

ButtoN makemRNAMatch;

4584

5139

} ProtForm, PNTR ProtFormPtr;

4585

5140

4586

5141

static void ProtRefPtrToProtPage (DialoG d, Pointer data)

4819

5374

StaticPrompt (g, "Protein Names", 0, 0, programFont, 'c');

4820

5375

ppp->name = CreateVisibleStringDialog (g, 3, -1, 25);

4821

5376

5377

pfp->makemRNAMatch = CheckBox (ppp->protGrp [0], "Make overlapping mRNA product match protein name", NULL);

5378

Hide (pfp->makemRNAMatch);

4822

5379

f = HiddenGroup (ppp->protGrp [0], 0, 4, NULL);

4823

5380

StaticPrompt (f, "Description", 0, dialogTextHeight, programFont, 'c');

4824

5381

ppp->desc = DialogText (f, "", 25, NULL);

5048

5605

}

5049

5606

}

5050

5607

5608

static void ShowHideMakemRNAMatch (ProtFormPtr pfp, SeqFeatPtr sfp)

5609

{

5610

BioseqPtr bsp;

5611

SeqFeatPtr cds, mrna;

5612

SeqMgrFeatContext fcontext;

5613

if (pfp == NULL) return;

5614

5615

if (sfp == NULL || sfp->data.choice != SEQFEAT_PROT) {

5616

Hide (pfp->makemRNAMatch);

5617

} else {

5618

/* look for overlapping mRNA */

5619

bsp = BioseqFindFromSeqLoc (sfp->location);

5620

cds = SeqMgrGetCDSgivenProduct (bsp, &fcontext);

5621

if (cds == NULL) {

5622

Hide (pfp->makemRNAMatch);

5623

} else {

5624

mrna = SeqMgrGetOverlappingmRNA (cds->location, &fcontext);

5625

if (mrna == NULL) {

5626

Hide (pfp->makemRNAMatch);

5627

} else {

5628

Show (pfp->makemRNAMatch);

5629

}

5630

}

5631

}

5632

}

5633

5634

5051

5635

static void ProtRefPtrToForm (ForM f, Pointer data)

5052

5636

5053

5637

{

5080

5664

PointerToDialog (pfp->location, sfp->location);

5081

5665

PointerToDialog (pfp->product, sfp->product);

5082

5666

}

5667

ShowHideMakemRNAMatch (pfp, sfp);

5083

5668

SeqEntrySetScope (oldsep);

5084

5669

}

5085

5670

}

5179

5764

return (ForM) w;

5180

5765

}

5181

5766

5767

5768

static void MakemRNAProductMatchProteinName (SeqFeatPtr prot)

5769

{

5770

BioseqPtr bsp;

5771

ProtRefPtr prp;

5772

SeqFeatPtr cds, mrna;

5773

RnaRefPtr rrp;

5774

SeqMgrFeatContext fcontext;

5775

5776

if (prot == NULL || prot->data.choice != SEQFEAT_PROT) return;

5777

bsp = BioseqFindFromSeqLoc (prot->location);

5778

if (bsp == NULL) return;

5779

5780

cds = SeqMgrGetCDSgivenProduct (bsp, &fcontext);

5781

if (cds != NULL) {

5782

mrna = SeqMgrGetOverlappingmRNA (cds->location, &fcontext);

5783

if (mrna != NULL && mrna->idx.subtype == FEATDEF_mRNA) {

5784

rrp = (RnaRefPtr) mrna->data.value.ptrvalue;

5785

if (rrp == NULL) {

5786

rrp = RnaRefNew();

5787

mrna->data.value.ptrvalue = rrp;

5788

}

5789

rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);

5790

prp = (ProtRefPtr) prot->data.value.ptrvalue;

5791

if (prp == NULL || prp->name == NULL || StringHasNoText (prp->name->data.ptrvalue)) {

5792

rrp->ext.choice = 0;

5793

} else {

5794

rrp->ext.choice = 1;

5795

rrp->ext.value.ptrvalue = StringSave (prp->name->data.ptrvalue);

5796

}

5797

}

5798

}

5799

}

5800

5801

5182

5802

static void ProtFeatFormActnProc (ForM f)

5183

5803

5184

5804

{

5185

5805

BioseqPtr bsp;

5186

5806

ProtFormPtr pfp;

5187

5807

SeqFeatPtr sfp;

5808

Boolean need_update = FALSE;

5188

5809

5189

5810

StdFeatFormActnProc (f);

5190

5811

pfp = (ProtFormPtr) GetObjectExtra (f);

5191

5812

if (pfp == NULL) return;

5813

5192

5814

sfp = SeqMgrGetDesiredFeature (pfp->input_entityID, NULL,

5193

5815

pfp->input_itemID, 0, NULL, NULL);

5194

5816

if (sfp == NULL) return;

5817

5195

5818

bsp = BioseqFindFromSeqLoc (sfp->location);

5196

5819

if (bsp == NULL) return;

5820

5821

if (GetStatus (pfp->makemRNAMatch)) {

5822

MakemRNAProductMatchProteinName (sfp);

5823

need_update = TRUE;

5824

}

5825

5197

5826

if (SeeIfProtTitleNeedsFixing (bsp, pfp->input_entityID)) {

5827

need_update = TRUE;

5828

}

5829

if (need_update) {

5198

5830

ObjMgrSendMsg (OM_MSG_UPDATE, pfp->input_entityID,

5199

5831

pfp->input_itemID, pfp->input_itemtype);

5200

}

5832

}

5201

5833

}

5202

5834

5203

5835

extern Int2 LIBCALLBACK ProtGenFunc (Pointer data)

5313

5945

{"mRNA", 2},

5314

5946

{"tRNA", 3},

5315

5947

{"rRNA", 4},

5316

{"snRNA", 5},

5317

{"scRNA", 6},

5318

{"snoRNA", 7},

5948

{"ncRNA", 8},

5949

{"tmRNA", 9},

5319

5950

{"misc_RNA", 255},

5320

5951

END_ENUM_ALIST

5321

5952

5322

5953

static Uint1 check_rna_type (Uint1 type)

5323

5954

5324

5955

{

5325

if (type > 7 && type != 255) return 0;

5956

if (type > 9 && type != 255) return 0;

5326

5957

return type;

5327

5958

}

5328

5959

5418

6049

return (DialoG) p;

5419

6050

}

5420

6051

5421

/* trna aa conversion modified from Tatiana Tatusov's code */

6052

6053

static Uint1 RnaFeatDefFromRnaRef (RnaRefPtr rrp)

6054

{

6055

if (rrp == NULL) {

6056

return FEATDEF_otherRNA;

6057

}

6058

6059

switch (rrp->type)

6060

{

6061

case 1:

6062

return FEATDEF_preRNA;

6063

break;

6064

case 2:

6065

return FEATDEF_mRNA;

6066

break;

6067

case 3:

6068

return FEATDEF_tRNA;

6069

break;

6070

case 4:

6071

return FEATDEF_rRNA;

6072

break;

6073

case 5:

6074

return FEATDEF_snRNA;

6075

break;

6076

case 6:

6077

return FEATDEF_scRNA;

6078

break;

6079

case 7:

6080

return FEATDEF_snoRNA;

6081

break;

6082

case 255:

6083

if (rrp->ext.choice != 1 || StringHasNoText (rrp->ext.value.ptrvalue)) {

6084

return FEATDEF_otherRNA;

6085

} else if (StringCmp (rrp->ext.value.ptrvalue, "ncRNA") == 0

6086

|| IsStringInNcRNAClassList(rrp->ext.value.ptrvalue)) {

6087

return FEATDEF_ncRNA;

6088

} else if (StringCmp (rrp->ext.value.ptrvalue, "tmRNA") == 0) {

6089

return FEATDEF_tmRNA;

6090

} else {

6091

return FEATDEF_otherRNA;

6092

}

6093

default:

6094

return FEATDEF_otherRNA;

6095

break;

6096

}

6097

}

6098

6099

6100

static Uint1 RnaSubtypeFromRnaRef (RnaRefPtr rrp)

6101

{

6102

if (rrp == NULL) {

6103

return 0;

6104

}

6105

6106

if (rrp->type == 255) {

6107

if (rrp->ext.choice == 1 && StringCmp (rrp->ext.value.ptrvalue, "tmRNA") == 0) {

6108

return 9;

6109

} else if (StringCmp (rrp->ext.value.ptrvalue, "ncRNA") == 0

6110

|| IsStringInNcRNAClassList (rrp->ext.value.ptrvalue)) {

6111

return 8;

6112

} else {

6113

return 255;

6114

}

6115

} else if (rrp->type == 5 || rrp->type == 6 || rrp->type == 7) {

6116

return 8;

6117

} else {

6118

return rrp->type;

6119

}

6120

}

6121

5422

6122

5423

6123

static void RnaRefPtrToRnaPage (DialoG d, Pointer data)

5424

6124

5441

6141

rrp = (RnaRefPtr) data;

5442

6142

5443

6143

if (rrp != NULL) {

6144

5444

6145

SetEnumPopup (rpp->type, rna_type_alist,

5445

(UIEnum) check_rna_type (rrp->type));

6146

RnaSubtypeFromRnaRef(rrp));

5446

6147

SafeSetStatus (rpp->pseudo, rrp->pseudo);

5447

6148

switch (rrp->type) {

5448

6149

case 0 :

5450

6151

SafeHide (rpp->nameGrp);

5451

6152

SafeHide (rpp->rrnaPrompt);

5452

6153

SafeHide (rpp->ornaPrompt);

6154

SafeHide (rpp->ncrnaGrp);

6155

SafeHide (rpp->tmrnaGrp);

5453

6156

break;

5454

6157

case 3 :

5455

6158

SafeSetTitle (rpp->name, "");

5456

6159

SafeHide (rpp->nameGrp);

5457

6160

SafeHide (rpp->rrnaPrompt);

5458

6161

SafeHide (rpp->ornaPrompt);

6162

SafeHide (rpp->ncrnaGrp);

6163

SafeHide (rpp->tmrnaGrp);

5459

6164

SafeSetValue (rpp->AAitem, 1);

5460

6165

if (rrp->ext.choice == 2) {

5461

6166

trna = rrp->ext.value.ptrvalue;

5560

6265

SafeHide (rpp->ornaPrompt);

5561

6266

SafeShow (rpp->rrnaPrompt);

5562

6267

SafeShow (rpp->nameGrp);

6268

SafeHide (rpp->ncrnaGrp);

6269

SafeHide (rpp->tmrnaGrp);

5563

6270

break;

6271

case 5:

6272

case 6:

6273

case 7:

6274

case 8:

5564

6275

case 255 :

5565

6276

SafeHide (rpp->trnaGrp);

5566

if (rrp->ext.choice == 1 && rrp->ext.value.ptrvalue != NULL) {

5567

SafeSetTitle (rpp->name, (CharPtr) rrp->ext.value.ptrvalue);

5568

} else {

5569

SafeSetTitle (rpp->name, "");

6277

SafeHide (rpp->nameGrp);

6278

SafeHide (rpp->rrnaPrompt);

6279

SafeHide (rpp->ornaPrompt);

6280

if (rrp->type == 5) {

6281

PointerToDialog (rpp->ncrnaClass, "snRNA");

6282

SafeHide (rpp->tmrnaGrp);

6283

SafeShow (rpp->ncrnaGrp);

6284

} else if (rrp->type == 6) {

6285

PointerToDialog (rpp->ncrnaClass, "scRNA");

6286

SafeHide (rpp->tmrnaGrp);

6287

SafeShow (rpp->ncrnaGrp);

6288

} else if (rrp->type == 7) {

6289

PointerToDialog (rpp->ncrnaClass, "snoRNA");

6290

SafeHide (rpp->tmrnaGrp);

6291

SafeShow (rpp->ncrnaGrp);

6292

} else if (rrp->type == 255) {

6293

if (rrp->ext.choice == 1) {

6294

if (StringCmp (rrp->ext.value.ptrvalue, "ncRNA") == 0) {

6295

SafeHide (rpp->tmrnaGrp);

6296

SafeShow (rpp->ncrnaGrp);

6297

/* get class from qual */

6298

} else if (IsStringInNcRNAClassList (rrp->ext.value.ptrvalue)) {

6299

SafeHide (rpp->tmrnaGrp);

6300

SafeShow (rpp->ncrnaGrp);

6301

/* get class from rrp */

6302

PointerToDialog (rpp->ncrnaClass, rrp->ext.value.ptrvalue);

6303

} else if (StringCmp (rrp->ext.value.ptrvalue, "tmRNA") == 0) {

6304

SafeHide (rpp->ncrnaGrp);

6305

SafeShow (rpp->tmrnaGrp);

6306

} else {

6307

if (StringCmp (rrp->ext.value.ptrvalue, "misc_RNA") != 0) {

6308

SafeSetTitle (rpp->name, (CharPtr) rrp->ext.value.ptrvalue);

6309

}

6310

SafeHide (rpp->ornaPrompt);

6311

SafeShow (rpp->rrnaPrompt);

6312

SafeShow (rpp->nameGrp);

6313

SafeHide (rpp->ncrnaGrp);

6314

SafeHide (rpp->tmrnaGrp);

6315

}

6316

} else {

6317

SafeSetTitle (rpp->name, "");

6318

SafeHide (rpp->ornaPrompt);

6319

SafeShow (rpp->rrnaPrompt);

6320

SafeShow (rpp->nameGrp);

6321

SafeHide (rpp->ncrnaGrp);

6322

SafeHide (rpp->tmrnaGrp);

6323

}

5570

6324

}

5571

SafeHide (rpp->rrnaPrompt);

5572

SafeShow (rpp->ornaPrompt);

5573

SafeShow (rpp->nameGrp);

5574

6325

break;

5575

6326

default :

5576

6327

SafeHide (rpp->trnaGrp);

5582

6333

SafeHide (rpp->rrnaPrompt);

5583

6334

SafeHide (rpp->ornaPrompt);

5584

6335

SafeShow (rpp->nameGrp);

6336

SafeHide (rpp->ncrnaGrp);

6337

SafeHide (rpp->tmrnaGrp);

5585

6338

break;

5586

6339

}

5587

6340

} else {

5593

6346

SafeHide (rpp->ornaPrompt);

5594

6347

SafeSetValue (rpp->AAitem, 0);

5595

6348

SafeHide (rpp->trnaGrp);

6349

SafeHide (rpp->ncrnaGrp);

6350

SafeHide (rpp->tmrnaGrp);

5596

6351

}

5597

6352

}

5598

6353

5622

6377

rrp = RnaRefNew ();

5623

6378

if (rrp != NULL) {

5624

6379

if (GetEnumPopup (rpp->type, rna_type_alist, &val)) {

5625

rrp->type = (Uint1) val;

6380

if (val == 8 || val == 9) {

6381

rrp->type = 255;

6382

} else {

6383

rrp->type = (Uint1) val;

6384

}

5626

6385

}

5627

6386

rrp->pseudo = GetStatus (rpp->pseudo);

5628

switch (rrp->type) {

6387

switch (val) {

5629

6388

case 3 :

5630

6389

rrp->ext.choice = 2;

5631

6390

trna = (tRNAPtr) MemNew (sizeof (tRNA));

5694

6453

trna->anticodon = DialogToPointer (rpp->anticodon);

5695

6454

}

5696

6455

break;

6456

case 5:

6457

case 6:

6458

case 7:

6459

case 8: /* ncRNA */

6460

rrp->ext.choice = 1;

6461

rrp->ext.value.ptrvalue = StringSave ("ncRNA");

6462

break;

6463

case 9: /* tmRNA */

6464

rrp->ext.choice = 1;

6465

rrp->ext.value.ptrvalue = StringSave ("tmRNA");

6466

break;

6467

case 255:

5697

6468

default :

5698

6469

if (! TextHasNoText (rpp->name)) {

5699

6470

rrp->ext.choice = 1;

5706

6477

return (Pointer) rrp;

5707

6478

}

5708

6479

6480

6481

static GBQualPtr FindOrAddQual (SeqFeatPtr sfp, CharPtr qual_name)

6482

{

6483

GBQualPtr gbq;

6484

6485

if (sfp == NULL) return NULL;

6486

gbq = sfp->qual;

6487

while (gbq != NULL && StringCmp (gbq->qual, qual_name) != 0) {

6488

gbq = gbq->next;

6489

}

6490

if (gbq == NULL) {

6491

gbq = GBQualNew ();

6492

gbq->qual = StringSave (qual_name);

6493

gbq->next = sfp->qual;

6494

sfp->qual = gbq;

6495

}

6496

return gbq;

6497

}

6498

6499

6500

static void RemoveQualByName (SeqFeatPtr sfp, CharPtr qual_name)

6501

{

6502

GBQualPtr gbq, gbq_next, gbq_prev = NULL;

6503

6504

if (sfp == NULL || StringHasNoText (qual_name))

6505

{

6506

return;

6507

}

6508

gbq = sfp->qual;

6509

while (gbq != NULL)

6510

{

6511

gbq_next = gbq->next;

6512

if (StringCmp (gbq->qual, qual_name) == 0)

6513

{

6514

if (gbq_prev == NULL)

6515

{

6516

sfp->qual = gbq->next;

6517

}

6518

else

6519

{

6520

gbq_prev->next = gbq->next;

6521

}

6522

gbq->next = NULL;

6523

gbq = GBQualFree (gbq);

6524

}

6525

else

6526

{

6527

gbq_prev = gbq;

6528

}

6529

gbq = gbq_next;

6530

}

6531

}

6532

6533

static void SetRNAMiscNameForType (SeqFeatPtr sfp, UIEnum val)

6534

{

6535

RnaRefPtr rrp;

6536

6537

if (sfp == NULL || sfp->data.choice != SEQFEAT_RNA) return;

6538

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

6539

6540

if (rrp == NULL) {

6541

rrp = RnaRefNew ();

6542

sfp->data.value.ptrvalue = rrp;

6543

}

6544

6545

if (val == 8) {

6546

rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);

6547

rrp->ext.value.ptrvalue = StringSave ("ncRNA");

6548

rrp->ext.choice = 1;

6549

} else if (val == 9) {

6550

rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);

6551

rrp->ext.value.ptrvalue = StringSave ("tmRNA");

6552

rrp->ext.choice = 1;

6553

} else if (val == 255) {

6554

rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);

6555

rrp->ext.value.ptrvalue = StringSave ("misc_RNA");

6556

rrp->ext.choice = 1;

6557

}

6558

6559

}

6560

6561

6562

extern void ConvertProductQualToRnaRefName (SeqFeatPtr sfp)

6563

{

6564

RnaRefPtr rrp;

6565

GBQualPtr gbq, gbq_prev = NULL;

6566

6567

if (sfp == NULL || sfp->data.choice != SEQFEAT_RNA || sfp->data.value.ptrvalue == NULL) return;

6568

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

6569

6570

gbq = sfp->qual;

6571

while (gbq != NULL && StringCmp (gbq->qual, "product") != 0) {

6572

gbq_prev = gbq;

6573

gbq = gbq->next;

6574

}

6575

if (gbq != NULL) {

6576

rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);

6577

rrp->ext.choice = 1;

6578

rrp->ext.value.ptrvalue = gbq->val;

6579

gbq->val = NULL;

6580

if (gbq_prev == NULL) {

6581

sfp->qual = gbq->next;

6582

} else {

6583

gbq_prev->next = gbq->next;

6584

}

6585

gbq->next = NULL;

6586

gbq = GBQualFree (gbq);

6587

}

6588

}

6589

6590

6591

static void ConvertRnaRefNameToProductQual (SeqFeatPtr sfp)

6592

{

6593

RnaRefPtr rrp;

6594

GBQualPtr gbq, gbq_prev = NULL;

6595

6596

if (sfp == NULL || sfp->data.choice != SEQFEAT_RNA || sfp->data.value.ptrvalue == NULL) return;

6597

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

6598

if (rrp->ext.choice != 1) return;

6599

6600

gbq = GBQualNew ();

6601

gbq->next = sfp->qual;

6602

sfp->qual = gbq;

6603

gbq->qual = StringSave ("product");

6604

gbq->val = StringSave (rrp->ext.value.ptrvalue);

6605

}

6606

6607

6608

static void AddRnaSpecificQualsForType (SeqFeatPtr sfp, RnaPagePtr rpp, UIEnum val)

6609

{

6610

CharPtr str;

6611

GBQualPtr gbq;

6612

RnaRefPtr rrp;

6613

6614

if (rpp == NULL || sfp == NULL || sfp->data.choice != SEQFEAT_RNA) return;

6615

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

6616

6617

if (val == 8) {

6618

str = DialogToPointer (rpp->ncrnaClass);

6619

if (StringHasNoText (str)) {

6620

str = MemFree (str);

6621

RemoveQualByName (sfp, "ncRNA_class");

6622

} else {

6623

gbq = FindOrAddQual (sfp, "ncRNA_class");

6624

gbq->val = MemFree (gbq->val);

6625

gbq->val = str;

6626

}

6627

if (TextHasNoText (rpp->ncrnaProduct)) {

6628

RemoveQualByName (sfp, "product");

6629

} else {

6630

gbq = FindOrAddQual (sfp, "product");

6631

gbq->val = MemFree (gbq->val);

6632

gbq->val = SaveStringFromText (rpp->ncrnaProduct);

6633

}

6634

} else if (val == 9) {

6635

str = DialogToPointer (rpp->tmrnaTagPeptide);

6636

if (StringHasNoText (str)) {

6637

str = MemFree (str);

6638

RemoveQualByName (sfp, "tag_peptide");

6639

} else {

6640

gbq = FindOrAddQual (sfp, "tag_peptide");

6641

gbq->val = MemFree (gbq->val);

6642

gbq->val = str;

6643

}

6644

if (TextHasNoText (rpp->tmrnaProduct)) {

6645

RemoveQualByName (sfp, "product");

6646

} else {

6647

gbq = FindOrAddQual (sfp, "product");

6648

gbq->val = MemFree (gbq->val);

6649

gbq->val = SaveStringFromText (rpp->tmrnaProduct);

6650

}

6651

} else if (val == 255) {

6652

if (TextHasNoText (rpp->name)) {

6653

RemoveQualByName (sfp, "product");

6654

} else {

6655

str = SaveStringFromText (rpp->name);

6656

if (StringCmp (str, "misc_RNA") == 0) {

6657

str = MemFree (str);

6658

} else {

6659

gbq = FindOrAddQual (sfp, "product");

6660

gbq->val = MemFree (gbq->val);

6661

gbq->val = str;

6662

}

6663

}

6664

}

6665

}

6666

6667

6668

extern void AddRnaSpecificQuals (SeqFeatPtr sfp, DialoG d)

6669

{

6670

RnaPagePtr rpp;

6671

UIEnum val;

6672

6673

rpp = (RnaPagePtr) GetObjectExtra (d);

6674

if (rpp == NULL || sfp == NULL) return;

6675

6676

if (GetEnumPopup (rpp->type, rna_type_alist, &val)) {

6677

AddRnaSpecificQualsForType (sfp, rpp, val);

6678

SetRNAMiscNameForType (sfp, val);

6679

if (val != 8) {

6680

RemoveQualByName (sfp, "ncRNA_class");

6681

}

6682

if (val != 8 && val != 9 && val != 255) {

6683

ConvertProductQualToRnaRefName (sfp);

6684

}

6685

}

6686

}

6687

6688

6689

extern void SetRnaSpecificQuals (SeqFeatPtr sfp, DialoG d)

6690

{

6691

RnaPagePtr rpp;

6692

RnaRefPtr rrp;

6693

GBQualPtr gbq;

6694

6695

rpp = (RnaPagePtr) GetObjectExtra (d);

6696

if (rpp == NULL || sfp == NULL || sfp->data.choice != SEQFEAT_RNA || sfp->data.value.ptrvalue == NULL) return;

6697

6698

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

6699

if ((rrp->type == 5 || rrp->type == 6 || rrp->type == 7)

6700

&& rrp->ext.choice == 1

6701

&& StringCmp (rrp->ext.value.ptrvalue, "ncRNA") != 0) {

6702

SetTitle (rpp->ncrnaProduct, rrp->ext.value.ptrvalue);

6703

}

6704

else if (rrp->type != 255 || rrp->ext.choice != 1) return;

6705

6706

if (StringCmp (rrp->ext.value.ptrvalue, "ncRNA") == 0) {

6707

gbq = sfp->qual;

6708

while (gbq != NULL) {

6709

if (StringCmp (gbq->qual, "ncRNA_class") == 0) {

6710

PointerToDialog (rpp->ncrnaClass, gbq->val);

6711

} else if (StringCmp (gbq->qual, "product") == 0) {

6712

SetTitle (rpp->ncrnaProduct, gbq->val);

6713

}

6714

gbq = gbq->next;

6715

}

6716

} else if (StringCmp (rrp->ext.value.ptrvalue, "tmRNA") == 0) {

6717

gbq = sfp->qual;

6718

while (gbq != NULL) {

6719

if (StringCmp (gbq->qual, "tag_peptide") == 0) {

6720

PointerToDialog (rpp->tmrnaTagPeptide, gbq->val);

6721

} else if (StringCmp (gbq->qual, "product") == 0) {

6722

SetTitle (rpp->tmrnaProduct, gbq->val);

6723

}

6724

gbq = gbq->next;

6725

}

6726

} else if (IsStringInNcRNAClassList (rrp->ext.value.ptrvalue)) {

6727

gbq = sfp->qual;

6728

while (gbq != NULL) {

6729

if (StringCmp (gbq->qual, "product") == 0) {

6730

SetTitle (rpp->ncrnaProduct, gbq->val);

6731

}

6732

gbq = gbq->next;

6733

}

6734

} else if (StringCmp (rrp->ext.value.ptrvalue, "misc_RNA") == 0) {

6735

gbq = sfp->qual;

6736

while (gbq != NULL) {

6737

if (StringCmp (gbq->qual, "product") == 0) {

6738

SetTitle (rpp->name, gbq->val);

6739

}

6740

gbq = gbq->next;

6741

}

6742

}

6743

}

6744

6745

6746

extern void ConvertToOldRNAFormat (SeqFeatPtr sfp)

6747

{

6748

RnaRefPtr rrp;

6749

GBQualPtr gbq, gbq_prod = NULL, gbq_class = NULL, gbq_prev = NULL, gbq_next;

6750

Boolean do_convert = TRUE;

6751

6752

if (sfp == NULL || sfp->data.choice != SEQFEAT_RNA)

6753

{

6754

return;

6755

}

6756

6757

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

6758

if (rrp == NULL || rrp->type != 255 || rrp->ext.choice != 1

6759

|| StringCmp (rrp->ext.value.ptrvalue, "ncRNA") != 0)

6760

{

6761

return;

6762

}

6763

for (gbq = sfp->qual; gbq != NULL && (gbq_prod == NULL || gbq_class == NULL); gbq = gbq->next)

6764

{

6765

if (StringCmp (gbq->qual, "ncRNA_class") == 0)

6766

{

6767

gbq_class = gbq;

6768

}

6769

else if (StringCmp (gbq->qual, "product") == 0)

6770

{

6771

gbq_prod = gbq;

6772

}

6773

}

6774

6775

if (gbq_class == NULL)

6776

{

6777

do_convert = FALSE;

6778

}

6779

else if (StringCmp (gbq_class->val, "snRNA") == 0)

6780

{

6781

rrp->type = 5;

6782

}

6783

else if (StringCmp (gbq_class->val, "scRNA") == 0)

6784

{

6785

rrp->type = 6;

6786

}

6787

else if (StringCmp (gbq_class->val, "snoRNA") == 0)

6788

{

6789

rrp->type = 7;

6790

}

6791

else if (IsStringInNcRNAClassList (gbq_class->val))

6792

{

6793

do_convert = FALSE;

6794

rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);

6795

rrp->ext.value.ptrvalue = StringSave (gbq_class->val);

6796

RemoveQualByName (sfp, "ncRNA_class");

6797

}

6798

else

6799

{

6800

do_convert = FALSE;

6801

}

6802

if (do_convert)

6803

{

6804

if (gbq_prod == NULL)

6805

{

6806

rrp->ext.choice = 0;

6807

rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);

6808

}

6809

else

6810

{

6811

rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);

6812

rrp->ext.value.ptrvalue = gbq_prod->val;

6813

gbq_prod->val = NULL;

6814

}

6815

gbq = sfp->qual;

6816

while (gbq != NULL)

6817

{

6818

gbq_next = gbq->next;

6819

if (StringCmp (gbq->qual, "ncRNA_class") == 0

6820

|| StringCmp (gbq->qual, "product") == 0)

6821

{

6822

if (gbq_prev == NULL)

6823

{

6824

sfp->qual = gbq->next;

6825

}

6826

else

6827

{

6828

gbq_prev->next = gbq->next;

6829

}

6830

gbq->next = NULL;

6831

gbq = GBQualFree (gbq);

6832

}

6833

else

6834

{

6835

gbq_prev = gbq;

6836

}

6837

gbq = gbq_next;

6838

}

6839

}

6840

}

6841

6842

5709

6843

static void SetRnaImportExportItems (RnaFormPtr rfp)

5710

6844

5711

6845

{

5750

6884

}

5751

6885

}

5752

6886

5753

static void ChangeRnaProc (PopuP p)

6887

static void SetRnaType (RnaPagePtr rpp, Uint2 subtype)

5754

6888

5755

6889

{

5756

6890

RnaFormPtr rfp;

5757

RnaPagePtr rpp;

5758

UIEnum val;

6891

RnaRefPtr rrp = NULL;

5759

6892

5760

rpp = (RnaPagePtr) GetObjectExtra (p);

5761

if (rpp != NULL) {

6893

if (rpp != NULL && rpp->rfp != NULL) {

5762

6894

rfp = rpp->rfp;

5763

if (GetEnumPopup (rpp->type, rna_type_alist, &val)) {

5764

switch (val) {

5765

case 0 :

5766

SafeHide (rpp->nameGrp);

5767

SafeHide (rpp->rrnaPrompt);

5768

SafeHide (rpp->ornaPrompt);

5769

SafeHide (rpp->trnaGrp);

5770

SafeHide (rfp->product);

5771

SafeHide (rfp->usrobjext);

5772

break;

5773

case 2 :

5774

SafeHide (rpp->trnaGrp);

5775

SafeHide (rpp->rrnaPrompt);

5776

SafeHide (rpp->ornaPrompt);

5777

SafeShow (rpp->nameGrp);

5778

SafeShow (rfp->product);

5779

SafeShow (rfp->usrobjext);

5780

break;

5781

case 3 :

5782

SafeHide (rpp->nameGrp);

5783

SafeHide (rpp->rrnaPrompt);

5784

SafeHide (rpp->ornaPrompt);

5785

SafeShow (rpp->trnaGrp);

5786

SafeShow (rfp->product);

5787

SafeHide (rfp->usrobjext);

5788

break;

5789

case 4 :

5790

SafeHide (rpp->trnaGrp);

5791

SafeHide (rpp->ornaPrompt);

5792

SafeShow (rpp->rrnaPrompt);

5793

SafeShow (rpp->nameGrp);

5794

SafeShow (rfp->product);

5795

SafeHide (rfp->usrobjext);

5796

break;

5797

case 5 :

5798

SafeHide (rpp->trnaGrp);

5799

SafeHide (rpp->rrnaPrompt);

5800

SafeHide (rpp->ornaPrompt);

5801

SafeShow (rpp->nameGrp);

5802

SafeShow (rfp->product);

5803

SafeHide (rfp->usrobjext);

5804

break;

5805

case 6 :

5806

SafeHide (rpp->trnaGrp);

5807

SafeHide (rpp->rrnaPrompt);

5808

SafeHide (rpp->ornaPrompt);

5809

SafeShow (rpp->nameGrp);

5810

SafeShow (rfp->product);

5811

SafeHide (rfp->usrobjext);

5812

break;

5813

case 7 :

5814

SafeHide (rpp->trnaGrp);

5815

SafeHide (rpp->rrnaPrompt);

5816

SafeHide (rpp->ornaPrompt);

5817

SafeShow (rpp->nameGrp);

5818

SafeShow (rfp->product);

5819

SafeHide (rfp->usrobjext);

5820

break;

5821

case 255 :

5822

SafeHide (rpp->trnaGrp);

5823

SafeHide (rpp->rrnaPrompt);

5824

SafeShow (rpp->ornaPrompt);

5825

SafeShow (rpp->nameGrp);

5826

SafeShow (rfp->product);

5827

SafeHide (rfp->usrobjext);

5828

break;

5829

default :

5830

SafeHide (rpp->trnaGrp);

5831

SafeHide (rpp->rrnaPrompt);

5832

SafeHide (rpp->ornaPrompt);

5833

SafeShow (rpp->nameGrp);

5834

SafeHide (rfp->product);

5835

SafeHide (rfp->usrobjext);

5836

break;

5837

}

6895

switch (subtype) {

6896

case 0 :

6897

SafeHide (rpp->nameGrp);

6898

SafeHide (rpp->rrnaPrompt);

6899

SafeHide (rpp->ornaPrompt);

6900

SafeHide (rpp->trnaGrp);

6901

SafeHide (rfp->product);

6902

SafeHide (rfp->usrobjext);

6903

SafeHide (rpp->ncrnaGrp);

6904

SafeHide (rpp->tmrnaGrp);

6905

break;

6906

case FEATDEF_mRNA:

6907

SafeHide (rpp->trnaGrp);

6908

SafeHide (rpp->rrnaPrompt);

6909

SafeHide (rpp->ornaPrompt);

6910

SafeShow (rpp->nameGrp);

6911

SafeShow (rfp->product);

6912

SafeShow (rfp->usrobjext);

6913

SafeHide (rpp->ncrnaGrp);

6914

SafeHide (rpp->tmrnaGrp);

6915

break;

6916

case FEATDEF_preRNA :

6917

SafeHide (rpp->trnaGrp);

6918

SafeHide (rpp->rrnaPrompt);

6919

SafeHide (rpp->ornaPrompt);

6920

SafeShow (rpp->nameGrp);

6921

SafeShow (rfp->product);

6922

SafeShow (rfp->usrobjext);

6923

SafeHide (rpp->ncrnaGrp);

6924

SafeHide (rpp->tmrnaGrp);

6925

break;

6926

case FEATDEF_tRNA :

6927

SafeHide (rpp->nameGrp);

6928

SafeHide (rpp->rrnaPrompt);

6929

SafeHide (rpp->ornaPrompt);

6930

SafeShow (rpp->trnaGrp);

6931

SafeShow (rfp->product);

6932

SafeHide (rfp->usrobjext);

6933

SafeHide (rpp->ncrnaGrp);

6934

SafeHide (rpp->tmrnaGrp);

6935

break;

6936

case FEATDEF_rRNA :

6937

SafeHide (rpp->trnaGrp);

6938

SafeHide (rpp->ornaPrompt);

6939

SafeShow (rpp->rrnaPrompt);

6940

SafeShow (rpp->nameGrp);

6941

SafeShow (rfp->product);

6942

SafeHide (rfp->usrobjext);

6943

SafeHide (rpp->ncrnaGrp);

6944

SafeHide (rpp->tmrnaGrp);

6945

break;

6946

case FEATDEF_snRNA :

6947

case FEATDEF_scRNA :

6948

case FEATDEF_snoRNA :

6949

SafeHide (rpp->trnaGrp);

6950

SafeHide (rpp->rrnaPrompt);

6951

SafeHide (rpp->ornaPrompt);

6952

SafeHide (rpp->nameGrp);

6953

SafeShow (rfp->product);

6954

SafeHide (rfp->usrobjext);

6955

SafeShow (rpp->ncrnaGrp);

6956

SafeHide (rpp->tmrnaGrp);

6957

if (subtype == FEATDEF_snRNA) {

6958

PointerToDialog (rpp->ncrnaClass, "snRNA");

6959

6960

} else if (subtype == FEATDEF_scRNA) {

6961

PointerToDialog (rpp->ncrnaClass, "scRNA");

6962

} else if (subtype == FEATDEF_snoRNA) {

6963

PointerToDialog (rpp->ncrnaClass, "snoRNA");

6964

} else if (subtype == FEATDEF_snoRNA) {

6965

PointerToDialog (rpp->ncrnaClass, "miscRNA");

6966

}

6967

break;

6968

6969

case FEATDEF_ncRNA :

6970

SafeHide (rpp->trnaGrp);

6971

SafeHide (rpp->rrnaPrompt);

6972

SafeHide (rpp->ornaPrompt);

6973

SafeHide (rpp->nameGrp);

6974

SafeShow (rfp->product);

6975

SafeHide (rfp->usrobjext);

6976

SafeShow (rpp->ncrnaGrp);

6977

SafeHide (rpp->tmrnaGrp);

6978

break;

6979

case FEATDEF_tmRNA :

6980

SafeHide (rpp->trnaGrp);

6981

SafeHide (rpp->rrnaPrompt);

6982

SafeHide (rpp->ornaPrompt);

6983

SafeHide (rpp->nameGrp);

6984

SafeShow (rfp->product);

6985

SafeHide (rfp->usrobjext);

6986

SafeHide (rpp->ncrnaGrp);

6987

SafeShow (rpp->tmrnaGrp);

6988

break;

6989

case FEATDEF_otherRNA :

6990

SafeHide (rpp->trnaGrp);

6991

SafeHide (rpp->rrnaPrompt);

6992

SafeShow (rpp->ornaPrompt);

6993

SafeShow (rpp->nameGrp);

6994

SafeShow (rfp->product);

6995

SafeHide (rfp->usrobjext);

6996

break;

6997

default :

6998

SafeHide (rpp->trnaGrp);

6999

SafeHide (rpp->rrnaPrompt);

7000

SafeHide (rpp->ornaPrompt);

7001

SafeShow (rpp->nameGrp);

7002

SafeHide (rfp->product);

7003

SafeHide (rfp->usrobjext);

7004

SafeHide (rpp->ncrnaGrp);

7005

SafeHide (rpp->tmrnaGrp);

7006

break;

5838

7007

}

5839

7008

SetRnaImportExportItems (rpp->rfp);

5840

7009

Update ();

5892

7061

"Amino Acid", "Codons", "Anticodon", NULL

5893

7062

};

5894

7063

7064

7065

static Uint1 RnaTypeFromFeatdef (Uint2 featdef)

7066

{

7067

switch (featdef)

7068

{

7069

case FEATDEF_preRNA:

7070

return 1;

7071

break;

7072

case FEATDEF_mRNA:

7073

return 2;

7074

break;

7075

case FEATDEF_tRNA:

7076

return 3;

7077

break;

7078

case FEATDEF_rRNA:

7079

return 4;

7080

break;

7081

case FEATDEF_snRNA:

7082

return 8;

7083

break;

7084

case FEATDEF_scRNA:

7085

return 8;

7086

break;

7087

case FEATDEF_snoRNA:

7088

return 8;

7089

break;

7090

case FEATDEF_ncRNA:

7091

return 8;

7092

break;

7093

case FEATDEF_tmRNA:

7094

return 9;

7095

break;

7096

case FEATDEF_otherRNA:

7097

default:

7098

return 255;

7099

break;

7100

}

7101

}

7102

7103

7104

static void ChangeRNAType (PopuP p)

7105

7106

{

7107

Char ch;

7108

Int2 expev;

7109

Int2 geneval;

7110

HelpMessageFunc helpfunc;

7111

RnaFormPtr rfp;

7112

RnaFormPtr newrfp;

7113

RnaRefPtr rrp;

7114

RnaPagePtr rpp;

7115

ObjMgrPtr omp;

7116

ObjMgrTypePtr omtp;

7117

CharPtr ptr;

7118

SeqEntryPtr sep;

7119

SeqFeatPtr sfp;

7120

Char title [128];

7121

WindoW w;

7122

UIEnum val;

7123

GBQualPtr gbq;

7124

7125

rfp = (RnaFormPtr) GetObjectExtra (p);

7126

if (rfp == NULL) return;

7127

rpp = (RnaPagePtr) GetObjectExtra (rfp->data);

7128

if (rpp == NULL) return;

7129

sfp = SeqFeatNew ();

7130

if (sfp != NULL) {

7131

if (GetEnumPopup (rpp->type, rna_type_alist, &val)) {

7132

7133

sfp->data.choice = SEQFEAT_RNA;

7134

sfp->data.value.ptrvalue = DialogToPointer (rfp->data);

7135

sfp->comment = SaveStringFromText (rfp->comment);

7136

ptr = sfp->comment;

7137

if (ptr != NULL) {

7138

ch = *ptr;

7139

while (ch != '\0') {

7140

if (ch < ' ' || ch > '~') {

7141

*ptr = '~';

7142

}

7143

ptr++;

7144

ch = *ptr;

7145

}

7146

}

7147

expev = GetValue (rfp->evidence);

7148

if (expev > 0 && expev <= 3) {

7149

sfp->exp_ev = expev - 1;

7150

} else {

7151

sfp->exp_ev = 0;

7152

}

7153

sfp->partial = GetStatus (rfp->partial);

7154

sfp->excpt = GetStatus (rfp->exception);

7155

sfp->title = NULL;

7156

sfp->product = DialogToPointer (rfp->product);

7157

sfp->location = DialogToPointer (rfp->location);

7158

sfp->cit = DialogToPointer (rfp->featcits);

7159

sfp->dbxref = DialogToPointer (rfp->dbxrefs);

7160

sfp->qual = DialogToPointer (rfp->gbquals);

7161

CleanupEvidenceGBQuals (&(sfp->qual));

7162

VisStringDialogToGbquals (sfp, rfp->experiment, "experiment");

7163

InferenceDialogToGBQuals (rfp->inference, sfp, TRUE);

7164

AddRnaSpecificQualsForType (sfp, rpp, rpp->prev_rna_type < 0 ? val : rpp->prev_rna_type);

7165

if (rpp->prev_rna_type == 8 && val != 8) {

7166

RemoveQualByName (sfp, "ncRNA_class");

7167

}

7168

if (rpp->prev_rna_type == 8 || rpp->prev_rna_type == 9 || rpp->prev_rna_type == 255) {

7169

if (val != 8 && val != 9 && val != 255) {

7170

ConvertProductQualToRnaRefName (sfp);

7171

}

7172

} else if (val == 8 || val == 9 || val == 255) {

7173

if (rpp->name != NULL && !TextHasNoText (rpp->name)) {

7174

gbq = FindOrAddQual (sfp, "product");

7175

gbq->val = SaveStringFromText (rpp->name);

7176

}

7177

}

7178

7179

SetRNAMiscNameForType (sfp, val);

7180

rpp->prev_rna_type = val;

7181

7182

geneval = GetValue (rfp->gene);

7183

sep = GetTopSeqEntryForEntityID (rfp->input_entityID);

7184

StringCpy (title, "RNA");

7185

if (sfp != NULL && sfp->data.value.ptrvalue != NULL) {

7186

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

7187

/* set title based on type of RNA feature */

7188

}

7189

/* need to set subtype to correctly calculate which quals should be suppressed */

7190

sfp->idx.subtype = RnaFeatDefFromRnaRef ((RnaRefPtr)sfp->data.value.ptrvalue);

7191

w = (WindoW) CreateRnaForm (-50, -33, title, sfp, sep, RnaFeatDefFromRnaRef (rrp),

7192

StdFeatFormActnProc);

7193

newrfp = (RnaFormPtr) GetObjectExtra (w);

7194

if (newrfp != NULL) {

7195

newrfp->input_entityID = rfp->input_entityID;

7196

newrfp->input_itemID = rfp->input_itemID;

7197

newrfp->input_itemtype = rfp->input_itemtype;

7198

newrfp->this_itemtype = rfp->this_itemtype;

7199

newrfp->this_subtype = rfp->this_subtype;

7200

if (sfp != NULL) {

7201

omp = ObjMgrGet ();

7202

if (omp != NULL) {

7203

omtp = ObjMgrTypeFind (omp, OBJ_SEQFEAT, NULL, NULL);

7204

if (omtp != NULL && omtp->subtypefunc != NULL) {

7205

newrfp->this_subtype = (*(omtp->subtypefunc)) (sfp);

7206

}

7207

}

7208

}

7209

SendMessageToForm (newrfp->form, VIB_MSG_INIT);

7210

SetValue (newrfp->gene, geneval);

7211

if (sfp != NULL) {

7212

PointerToForm (newrfp->form, (Pointer) sfp);

7213

}

7214

}

7215

Remove (rfp->form);

7216

Show (w);

7217

Select (w);

7218

helpfunc = (HelpMessageFunc) GetAppProperty ("HelpMessageProc");

7219

if (helpfunc != NULL) {

7220

helpfunc ("Features", title);

7221

}

7222

}

7223

SeqFeatFree (sfp);

7224

Update ();

7225

}

7226

}

7227

7228

7229

7230

5895

7231

static DialoG CreateRnaDialog (GrouP h, CharPtr title,

5896

7232

Uint2 subtype, SeqEntryPtr sep,

5897

7233

SeqFeatPtr sfp, RnaFormPtr rfp)

5911

7247

PrompT t;

5912

7248

DialoG tbs;

5913

7249

GrouP x;

7250

Uint1 rna_type;

7251

Uint2 entityID;

5914

7252

5915

7253

p = HiddenGroup (h, 1, 0, NULL);

5916

7254

SetGroupSpacing (p, 10, 10);

5924

7262

rpp->fromdialog = RnaPageToRnaRefPtr;

5925

7263

rpp->testdialog = NULL;

5926

7264

7265

rpp->prev_rna_type = -1;

7266

5927

7267

if (title != NULL && title [0] != '\0') {

5928

7268

s = NormalGroup (p, 0, -2, title, systemFont, NULL);

5929

7269

} else {

5936

7276

5937

7277

f = HiddenGroup (m, -2, 0, NULL);

5938

7278

StaticPrompt (f, "Type", 0, popupMenuHeight, programFont, 'l');

5939

rpp->type = PopupList (f, TRUE, ChangeRnaProc);

5940

SetObjectExtra (rpp->type, rpp, NULL);

7279

rpp->type = PopupList (f, TRUE, ChangeRNAType);

7280

SetObjectExtra (rpp->type, rfp, NULL);

5941

7281

InitEnumPopup (rpp->type, rna_type_alist, NULL);

5942

7282

SetEnumPopup (rpp->type, rna_type_alist, (UIEnum) 0);

5943

7283

7284

StaticPrompt (m, "Changing RNA type will recreate the window.",

7285

0, 0, programFont, 'c');

7286

5944

7287

showpseudo = FALSE;

5945

7288

if (sfp != NULL && sfp->data.choice == SEQFEAT_RNA) {

5946

7289

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

5965

7308

x = HiddenGroup (rpp->nameGrp, 0, 0, NULL);

5966

7309

rpp->rrnaPrompt = StaticPrompt (x, "E.g., 16S ribosomal RNA", 0, 0, programFont, 'c');

5967

7310

rpp->ornaPrompt = StaticPrompt (x, "E.g., internal transcribed spacer 1", 0, 0, programFont, 'c');

5968

if ((sfp != NULL && (sfp->product != NULL || sfp->ext != NULL)) || indexerVersion) {

5969

rfp->product = CreateProteinOrMRNAProductDialog (rpp->nameGrp, NULL, "cDNA Product ", TRUE, sep, NULL, rfp, (BaseFormPtr) rfp);

5970

rfp->usrobjext = CreateMrnaUserObjectDialog (rpp->nameGrp, "Protein Product", sep, (BaseFormPtr) rfp);

5971

}

5972

if ((sfp != NULL && sfp->product != NULL) || indexerVersion) {

5973

x = HiddenGroup (rpp->nameGrp, 2, 0, NULL);

5974

StaticPrompt (x, "SeqID", 0, dialogTextHeight, programFont, 'l');

5975

rfp->prodSeqIdTxt = DialogText (x, "", 6, NULL);

5976

}

5977

7311

AlignObjects (ALIGN_CENTER, (HANDLE) q, (HANDLE) rpp->rrnaPrompt, (HANDLE) rpp->ornaPrompt, NULL);

5978

7312

Hide (rpp->nameGrp);

5979

7313

6004

7338

(HANDLE) rpp->trnaPages [2], NULL);

6005

7339

AlignObjects (ALIGN_CENTER, (HANDLE) f, (HANDLE) rpp->nameGrp,

6006

7340

(HANDLE) rpp->trnaGrp, (HANDLE) rpp->pseudo,NULL);

6007

6008

switch (subtype) {

6009

case 0 :

6010

SafeHide (rpp->nameGrp);

6011

SafeHide (rpp->rrnaPrompt);

6012

SafeHide (rpp->ornaPrompt);

6013

SafeHide (rpp->trnaGrp);

6014

SafeHide (rfp->product);

6015

SafeHide (rfp->usrobjext);

6016

break;

6017

case FEATDEF_mRNA :

6018

SafeHide (rpp->trnaGrp);

6019

SafeHide (rpp->rrnaPrompt);

6020

SafeHide (rpp->ornaPrompt);

6021

SafeShow (rpp->nameGrp);

6022

SafeShow (rfp->product);

6023

SafeShow (rfp->usrobjext);

6024

break;

6025

case FEATDEF_tRNA :

6026

SafeHide (rpp->nameGrp);

6027

SafeHide (rpp->rrnaPrompt);

6028

SafeHide (rpp->ornaPrompt);

6029

SafeShow (rpp->trnaGrp);

6030

SafeShow (rfp->product);

6031

SafeHide (rfp->usrobjext);

6032

break;

6033

case FEATDEF_rRNA :

6034

SafeHide (rpp->trnaGrp);

6035

SafeHide (rpp->ornaPrompt);

6036

SafeShow (rpp->rrnaPrompt);

6037

SafeShow (rpp->nameGrp);

6038

SafeShow (rfp->product);

6039

SafeHide (rfp->usrobjext);

6040

break;

6041

case FEATDEF_snRNA :

6042

SafeHide (rpp->trnaGrp);

6043

SafeHide (rpp->ornaPrompt);

6044

SafeHide (rpp->rrnaPrompt);

6045

SafeShow (rpp->nameGrp);

6046

SafeShow (rfp->product);

6047

SafeHide (rfp->usrobjext);

6048

break;

6049

case FEATDEF_scRNA :

6050

SafeHide (rpp->trnaGrp);

6051

SafeHide (rpp->ornaPrompt);

6052

SafeHide (rpp->rrnaPrompt);

6053

SafeShow (rpp->nameGrp);

6054

SafeShow (rfp->product);

6055

SafeHide (rfp->usrobjext);

6056

break;

6057

case FEATDEF_snoRNA :

6058

SafeHide (rpp->trnaGrp);

6059

SafeHide (rpp->ornaPrompt);

6060

SafeHide (rpp->rrnaPrompt);

6061

SafeShow (rpp->nameGrp);

6062

SafeShow (rfp->product);

6063

SafeHide (rfp->usrobjext);

6064

break;

6065

case FEATDEF_otherRNA :

6066

SafeHide (rpp->trnaGrp);

6067

SafeHide (rpp->rrnaPrompt);

6068

SafeShow (rpp->ornaPrompt);

6069

SafeShow (rpp->nameGrp);

6070

SafeShow (rfp->product);

6071

SafeHide (rfp->usrobjext);

6072

break;

6073

default :

6074

SafeHide (rpp->trnaGrp);

6075

SafeHide (rpp->ornaPrompt);

6076

SafeHide (rpp->rrnaPrompt);

6077

SafeShow (rpp->nameGrp);

6078

SafeHide (rfp->product);

6079

SafeHide (rfp->usrobjext);

6080

break;

6081

}

7341

Hide (rpp->ncrnaGrp);

7342

7343

rpp->ncrnaGrp = HiddenGroup (g, 2, 0, NULL);

7344

SetGroupSpacing (rpp->ncrnaGrp, 10, 10);

7345

StaticPrompt (rpp->ncrnaGrp, "Class", 0, popupMenuHeight, programFont, 'l');

7346

rpp->ncrnaClass = CreatencRNAClassDialog (rpp->ncrnaGrp, FALSE, NULL, NULL);

7347

StaticPrompt (rpp->ncrnaGrp, "Product", 0, dialogTextHeight, programFont, 'l');

7348

rpp->ncrnaProduct = DialogText (rpp->ncrnaGrp, "", 10, NULL);

7349

Hide (rpp->ncrnaGrp);

7350

7351

rpp->tmrnaGrp = HiddenGroup (g, 2, 0, NULL);

7352

SetGroupSpacing (rpp->tmrnaGrp, 10, 10);

7353

StaticPrompt (rpp->tmrnaGrp, "Tag Peptide", 0, dialogTextHeight, programFont, 'l');

7354

rpp->tmrnaTagPeptide = CreateRptUnitRangeDialog (rpp->tmrnaGrp, NULL, NULL, NULL, NULL);

7355

StaticPrompt (rpp->tmrnaGrp, "Product", 0, dialogTextHeight, programFont, 'l');

7356

rpp->tmrnaProduct = DialogText (rpp->tmrnaGrp, "", 10, NULL);

7357

Hide (rpp->tmrnaGrp);

7358

7359

if (sfp != NULL && sfp->data.choice == SEQFEAT_RNA && sfp->data.value.ptrvalue != NULL) {

7360

rna_type = RnaSubtypeFromRnaRef ((RnaRefPtr)sfp->data.value.ptrvalue);

7361

} else {

7362

rna_type = RnaTypeFromFeatdef (subtype);

7363

}

7364

SetEnumPopup (rpp->type, rna_type_alist, (UIEnum) rna_type);

7365

rpp->prev_rna_type = rna_type;

7366

7367

if ((sfp != NULL && sfp->product != NULL) || indexerVersion) {

7368

entityID = SeqMgrGetEntityIDForSeqEntry(sep);

7369

rfp->product = CreateRNATranscriptIDDialog (m, entityID, TRUE, NULL, NULL);

7370

}

7371

7372

SetRnaType (rpp, subtype);

6082

7373

}

6083

7374

6084

7375

return (DialoG) p;

6277

7568

static void RnaRefPtrToForm (ForM f, Pointer data)

6278

7569

6279

7570

{

6280

BioseqPtr bsp;

6281

Char id [41];

6282

7571

SeqEntryPtr oldsep;

6283

7572

RnaFormPtr rfp;

6284

7573

SeqEntryPtr sep;

6285

7574

SeqFeatPtr sfp;

6286

SeqIdPtr sip;

6287

7575

Int4 val;

6288

7576

6289

7577

rfp = (RnaFormPtr) GetObjectExtra (f);

6308

7596

}

6309

7597

SeqFeatPtrToCommon ((FeatureFormPtr) rfp, sfp);

6310

7598

PointerToDialog (rfp->product, sfp->product);

6311

if (sfp->product != NULL) {

6312

sip = SeqLocId (sfp->product);

6313

if (sip != NULL) {

6314

bsp = BioseqFind (sip);

6315

if (bsp == NULL) {

6316

SeqIdWrite (sip, id, PRINTID_FASTA_LONG, sizeof (id));

6317

SafeSetTitle (rfp->prodSeqIdTxt, id);

6318

}

6319

}

6320

}

6321

7599

}

6322

7600

SeqEntrySetScope (oldsep);

6323

7601

}

6411

7689

s = HiddenGroup (h, -1, 0, NULL);

6412

7690

SetGroupSpacing (s, 3, 10);

6413

7691

rfp->data = CreateRnaDialog (s, NULL, subtype, sep, sfp, rfp);

7692

SetRnaSpecificQuals (sfp, rfp->data);

6414

7693

rfp->pages [RNA_PAGE] = s;

6415

7694

Hide (rfp->pages [RNA_PAGE]);

6416

7695

rnaFormTabs [0] = NULL;

6523

7802

if (sfp != NULL && sfp->data.value.ptrvalue != NULL) {

6524

7803

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

6525

7804

StringNCpy_0 (title,

6526

GetEnumName ((UIEnum) rrp->type, rna_type_alist),

7805

GetEnumName (RnaSubtypeFromRnaRef(rrp), rna_type_alist),

6527

7806

sizeof (title));

6528

7807

if (StringHasNoText (title)) {

6529

7808

StringCpy (title, "Unknown RNA");

6579

7858

rpp = (RnaPagePtr) GetObjectExtra (rfp->data);

6580

7859

if (rpp != NULL) {

6581

7860

SetNewFeatureDefaultInterval ((FeatureFormPtr) rfp);

6582

if (subtype >= FEATDEF_preRNA && subtype <= FEATDEF_scRNA) {

6583

SetEnumPopup (rpp->type, rna_type_alist,

6584

(UIEnum) check_rna_type (subtype - FEATDEF_preRNA + 1));

6585

if (subtype == FEATDEF_tRNA)

6586

{

6587

/* attempt to provide default location for anticodons */

6588

SeqLocPtr tmp_loc = NULL;

6589

6590

tmp_loc = DialogToPointer (rpp->rfp->location);

6591

PointerToDialog (rpp->anticodon, tmp_loc);

6592

SetSequenceAndStrandForIntervalPage (rpp->anticodon);

6593

SeqLocFree (tmp_loc);

6594

}

6595

} else if (subtype == FEATDEF_snoRNA) {

6596

SetEnumPopup (rpp->type, rna_type_alist,

6597

(UIEnum) check_rna_type (7));

6598

} else if (subtype == FEATDEF_otherRNA) {

6599

SetEnumPopup (rpp->type, rna_type_alist,

6600

(UIEnum) check_rna_type (255));

6601

} else {

6602

SetEnumPopup (rpp->type, rna_type_alist, (UIEnum) 0);

7861

SetEnumPopup (rpp->type, rna_type_alist, RnaTypeFromFeatdef (subtype));

7862

if (subtype == FEATDEF_tRNA)

7863

{

7864

/* attempt to provide default location for anticodons */

7865

SeqLocPtr tmp_loc = NULL;

7866

7867

tmp_loc = DialogToPointer (rpp->rfp->location);

7868

PointerToDialog (rpp->anticodon, tmp_loc);

7869

SetSequenceAndStrandForIntervalPage (rpp->anticodon);

7870

SeqLocFree (tmp_loc);

6603

7871

}

6604

7872

}

6605

7873

}

6613

7881

return OM_MSG_RET_DONE;

6614

7882

}

6615

7883

7884

7885

typedef struct ncrnaclassdlg {

7886

DIALOG_MESSAGE_BLOCK

7887

PopuP ncrnaclass;

7888

TexT otherclass;

7889

Nlm_ChangeNotifyProc change_notify;

7890

Pointer change_userdata;

7891

Boolean is_constraint;

7892

7893

} NcrnaClassDlgData, PNTR NcrnaClassDlgPtr;

7894

7895

static void ChangeNcrnaClass (PopuP p)

7896

{

7897

NcrnaClassDlgPtr dlg;

7898

7899

dlg = (NcrnaClassDlgPtr) GetObjectExtra (p);

7900

if (dlg == NULL) return;

7901

7902

if (GetValue (dlg->ncrnaclass) == NcrnaOTHER) {

7903

Show (dlg->otherclass);

7904

} else {

7905

Hide (dlg->otherclass);

7906

}

7907

7908

if (dlg->change_notify != NULL) {

7909

(dlg->change_notify) (dlg->change_userdata);

7910

}

7911

}

7912

7913

7914

static void ChangeNcrnaOtherClass (TexT t)

7915

{

7916

NcrnaClassDlgPtr dlg;

7917

7918

dlg = (NcrnaClassDlgPtr) GetObjectExtra (t);

7919

if (dlg == NULL) return;

7920

if (dlg->change_notify != NULL) {

7921

(dlg->change_notify) (dlg->change_userdata);

7922

}

7923

}

7924

7925

7926

static void PointerToNcrnaClassDialog (DialoG d, Pointer data)

7927

{

7928

NcrnaClassDlgPtr dlg;

7929

CharPtr PNTR cpp;

7930

Int4 pos = NcrnaOTHER;

7931

7932

dlg = (NcrnaClassDlgPtr) GetObjectExtra (d);

7933

if (dlg == NULL) return;

7934

7935

if (data == NULL) {

7936

if (dlg->is_constraint) {

7937

pos = NcrnaOTHER + 1;

7938

}

7939

} else {

7940

if (data != NULL) {

7941

for (cpp = ncrnaClassList, pos = 1;

7942

*cpp != NULL && pos < NcrnaOTHER;

7943

cpp++, pos++) {

7944

if (StringCmp (*cpp, (CharPtr) data) == 0) {

7945

break;

7946

}

7947

}

7948

}

7949

}

7950

7951

SetValue (dlg->ncrnaclass, pos);

7952

if (pos == NcrnaOTHER) {

7953

SetTitle (dlg->otherclass, (CharPtr) data);

7954

Show (dlg->otherclass);

7955

} else {

7956

Hide (dlg->otherclass);

7957

}

7958

}

7959

7960

7961

static Pointer NcrnaClassDialogToPointer (DialoG d)

7962

{

7963

NcrnaClassDlgPtr dlg;

7964

Int4 pos;

7965

7966

dlg = (NcrnaClassDlgPtr) GetObjectExtra (d);

7967

if (dlg == NULL) return NULL;

7968

pos = GetValue (dlg->ncrnaclass);

7969

if (pos > 0 && pos < NcrnaOTHER) {

7970

return StringSave (ncrnaClassList[pos - 1]);

7971

} else if (pos == NcrnaOTHER && !TextHasNoText (dlg->otherclass)) {

7972

return SaveStringFromText (dlg->otherclass);

7973

} else {

7974

return NULL;

7975

}

7976

}

7977

7978

7979

static ValNodePtr TestNcrnaClassDialog (DialoG d)

7980

{

7981

ValNodePtr err_list = NULL;

7982

7983

NcrnaClassDlgPtr dlg;

7984

Int4 pos;

7985

7986

dlg = (NcrnaClassDlgPtr) GetObjectExtra (d);

7987

if (dlg == NULL) return NULL;

7988

pos = GetValue (dlg->ncrnaclass);

7989

7990

if (pos < 1 && !dlg->is_constraint) {

7991

ValNodeAddPointer (&err_list, 0, "No ncRNA class");

7992

} else if (pos == NcrnaOTHER) {

7993

if (TextHasNoText (dlg->otherclass)) {

7994

ValNodeAddPointer (&err_list, 0, "No ncRNA class");

7995

}

7996

} else if (!dlg->is_constraint && pos > NcrnaOTHER) {

7997

ValNodeAddPointer (&err_list, 0, "No ncRNA class");

7998

}

7999

return err_list;

8000

}

8001

8002

8003

extern DialoG CreatencRNAClassDialog (GrouP h, Boolean is_constraint, Nlm_ChangeNotifyProc change_notify, Pointer change_userdata)

8004

{

8005

NcrnaClassDlgPtr dlg;

8006

GrouP p;

8007

CharPtr PNTR cpp;

8008

8009

p = HiddenGroup (h, 2, 0, NULL);

8010

dlg = (NcrnaClassDlgPtr) MemNew (sizeof (NcrnaClassDlgData));

8011

SetObjectExtra (p, dlg, StdCleanupExtraProc);

8012

8013

dlg->dialog = (DialoG) p;

8014

dlg->todialog = PointerToNcrnaClassDialog;

8015

dlg->fromdialog = NcrnaClassDialogToPointer;

8016

dlg->testdialog = TestNcrnaClassDialog;

8017

dlg->change_notify = change_notify;

8018

dlg->change_userdata = change_userdata;

8019

dlg->is_constraint = is_constraint;

8020

8021

dlg->ncrnaclass = PopupList (p, TRUE, ChangeNcrnaClass);

8022

SetObjectExtra (dlg->ncrnaclass, dlg, NULL);

8023

for (cpp = ncrnaClassList; *cpp != NULL; cpp++) {

8024

PopupItem (dlg->ncrnaclass, *cpp);

8025

}

8026

if (is_constraint) {

8027

PopupItem (dlg->ncrnaclass, "Any");

8028

SetValue (dlg->ncrnaclass, NcrnaOTHER + 1);

8029

} else {

8030

SetValue (dlg->ncrnaclass, NcrnaOTHER);

8031

}

8032

dlg->otherclass = DialogText (p, "", 10, ChangeNcrnaOtherClass);

8033

SetObjectExtra (dlg->otherclass, dlg, NULL);

8034

8035

return (DialoG) p;

8036

}

8037

8038

8039

extern RnaTypePtr RnaTypeFree (RnaTypePtr rtp)

8040

{

8041

if (rtp != NULL)

8042

{

8043

rtp->ncrna_class = MemFree (rtp->ncrna_class);

8044

rtp = MemFree (rtp);

8045

}

8046

return rtp;

8047

}

8048

8049

8050

extern Boolean MatchesRnaType (SeqFeatPtr sfp, RnaTypePtr rtp)

8051

{

8052

RnaRefPtr rrp;

8053

GBQualPtr gbq;

8054

Uint1 featdef;

8055

Boolean matches = TRUE;

8056

8057

if (sfp == NULL || sfp->data.choice != SEQFEAT_RNA) return FALSE;

8058

if (rtp == NULL || rtp->rna_featdef == FEATDEF_ANY) return TRUE;

8059

8060

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

8061

if (rrp == NULL) return FALSE;

8062

8063

featdef = RnaFeatDefFromRnaRef (rrp);

8064

if (featdef != rtp->rna_featdef) return FALSE;

8065

8066

if (featdef == FEATDEF_ncRNA)

8067

{

8068

if (rtp->ncrna_class == NULL) {

8069

matches = TRUE;

8070

} else {

8071

gbq = sfp->qual;

8072

while (gbq != NULL && StringCmp (gbq->qual, "ncRNA_class") != 0)

8073

{

8074

gbq = gbq->next;

8075

}

8076

if (gbq == NULL)

8077

{

8078

if (rrp->ext.choice == 1 && StringCmp (rrp->ext.value.ptrvalue, rtp->ncrna_class) == 0)

8079

{

8080

matches = TRUE;

8081

}

8082

else if (StringDoesHaveText (rtp->ncrna_class))

8083

{

8084

matches = FALSE;

8085

}

8086

}

8087

else if (StringCmp (gbq->val, rtp->ncrna_class) != 0)

8088

{

8089

matches = FALSE;

8090

}

8091

}

8092

}

8093

return matches;

8094

}

8095

8096

8097

static void ClearRNAProduct (RnaRefPtr rrp)

8098

{

8099

tRNAPtr trna;

8100

8101

if (rrp == NULL || rrp->ext.choice == 0)

8102

{

8103

return;

8104

}

8105

if (rrp->ext.choice == 2)

8106

{

8107

trna = (tRNAPtr)(rrp->ext.value.ptrvalue);

8108

if (trna != NULL) {

8109

trna->anticodon = SeqLocFree(trna->anticodon);

8110

}

8111

}

8112

8113

rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);

8114

rrp->ext.choice = 0;

8115

}

8116

8117

8118

static void MoveRnaProductToQual (SeqFeatPtr sfp)

8119

{

8120

RnaRefPtr rrp;

8121

CharPtr product = NULL;

8122

GBQualPtr gbq;

8123

8124

if (sfp == NULL || sfp->data.choice != SEQFEAT_RNA || sfp->data.value.ptrvalue == NULL)

8125

{

8126

return;

8127

}

8128

8129

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

8130

if (rrp->ext.choice == 1)

8131

{

8132

product = rrp->ext.value.ptrvalue;

8133

rrp->ext.value.ptrvalue = NULL;

8134

}

8135

ClearRNAProduct (rrp);

8136

rrp->ext.choice = 1;

8137

rrp->ext.value.ptrvalue = StringSave ("ncRNA");

8138

if (product != NULL)

8139

{

8140

gbq = FindOrAddQual (sfp, "product");

8141

gbq->val = product;

8142

}

8143

}

8144

8145

8146

extern void ApplyRnaTypeToSeqFeat (SeqFeatPtr sfp, RnaTypePtr rtp)

8147

{

8148

RnaRefPtr rrp;

8149

GBQualPtr gbq;

8150

8151

if (sfp == NULL || sfp->data.choice != SEQFEAT_RNA)

8152

{

8153

return;

8154

}

8155

8156

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

8157

if (rrp == NULL)

8158

{

8159

rrp = RnaRefNew();

8160

sfp->data.value.ptrvalue = rrp;

8161

}

8162

8163

if (rtp == NULL || rtp->rna_featdef == FEATDEF_ANY)

8164

{

8165

return;

8166

}

8167

8168

switch (rtp->rna_featdef)

8169

{

8170

case FEATDEF_preRNA:

8171

rrp->type = 1;

8172

break;

8173

case FEATDEF_mRNA:

8174

rrp->type = 2;

8175

break;

8176

case FEATDEF_tRNA:

8177

rrp->type = 3;

8178

break;

8179

case FEATDEF_rRNA:

8180

rrp->type = 4;

8181

break;

8182

case FEATDEF_scRNA:

8183

rrp->type = 255;

8184

MoveRnaProductToQual (sfp);

8185

gbq = FindOrAddQual (sfp, "ncRNA_class");

8186

gbq->val = MemFree (gbq->val);

8187

gbq->val = StringSave ("scRNA");

8188

break;

8189

case FEATDEF_snRNA:

8190

rrp->type = 255;

8191

MoveRnaProductToQual (sfp);

8192

gbq = FindOrAddQual (sfp, "ncRNA_class");

8193

gbq->val = MemFree (gbq->val);

8194

gbq->val = StringSave ("snRNA");

8195

break;

8196

case FEATDEF_snoRNA:

8197

rrp->type = 255;

8198

MoveRnaProductToQual (sfp);

8199

gbq = FindOrAddQual (sfp, "ncRNA_class");

8200

gbq->val = MemFree (gbq->val);

8201

gbq->val = StringSave ("snoRNA");

8202

break;

8203

case FEATDEF_ncRNA:

8204

rrp->type = 255;

8205

MoveRnaProductToQual (sfp);

8206

gbq = FindOrAddQual (sfp, "ncRNA_class");

8207

gbq->val = MemFree (gbq->val);

8208

gbq->val = StringSave (rtp->ncrna_class);

8209

break;

8210

case FEATDEF_tmRNA:

8211

rrp->type = 255;

8212

MoveRnaProductToQual (sfp);

8213

rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);

8214

rrp->ext.value.ptrvalue = StringSave ("tmRNA");

8215

rrp->ext.choice = 1;

8216

break;

8217

case FEATDEF_otherRNA:

8218

rrp->type = 255;

8219

if (rrp->ext.choice == 1 && IsStringInNcRNAClassList (rrp->ext.value.ptrvalue))

8220

{

8221

gbq = FindOrAddQual (sfp, "ncRNA_class");

8222

gbq->val = MemFree (gbq->val);

8223

gbq->val = rrp->ext.value.ptrvalue;

8224

rrp->ext.value.ptrvalue = StringSave ("ncRNA");

8225

}

8226

break;

8227

}

8228

8229

}

8230

8231

8232

extern void AddToComment (SeqFeatPtr sfp, CharPtr comment)

8233

{

8234

CharPtr tmp;

8235

8236

if (sfp == NULL || StringHasNoText (comment)) return;

8237

8238

if (StringHasNoText (sfp->comment))

8239

{

8240

sfp->comment = MemFree (sfp->comment);

8241

sfp->comment = StringSave (comment);

8242

}

8243

else

8244

{

8245

tmp = (CharPtr) MemNew (sizeof (Char) * (StringLen (sfp->comment) + StringLen (comment) + 3));

8246

sprintf (tmp, "%s; %s", sfp->comment, comment);

8247

sfp->comment = MemFree (sfp->comment);

8248

sfp->comment = tmp;

8249

}

8250

}

8251

8252

8253

extern void ApplyProductToRNA (SeqFeatPtr sfp, CharPtr product)

8254

{

8255

RnaRefPtr rrp;

8256

GBQualPtr gbq;

8257

Uint1 aa;

8258

Int4 j;

8259

Boolean justTrnaText = FALSE;

8260

Char codon [16];

8261

tRNAPtr trp;

8262

8263

if (sfp == NULL || sfp->data.choice != SEQFEAT_RNA

8264

|| sfp->data.value.ptrvalue == NULL)

8265

{

8266

return;

8267

}

8268

8269

rrp = (RnaRefPtr) sfp->data.value.ptrvalue;

8270

if (rrp->type == 3)

8271

{

8272

ClearRNAProduct (rrp);

8273

8274

aa = ParseTRnaString (product, &justTrnaText, (Uint1Ptr) codon, TRUE);

8275

if (aa != 0)

8276

{

8277

trp = (tRNAPtr) MemNew (sizeof (tRNA));

8278

if (trp != NULL)

8279

{

8280

trp->aatype = 2;

8281

for (j = 0; j < 6; j++)

8282

{

8283

trp->codon [j] = 255;

8284

}

8285

if (justTrnaText)

8286

{

8287

for (j = 0; j < 6; j++)

8288

{

8289

trp->codon [j] = codon [j];

8290

}

8291

}

8292

trp->aa = aa;

8293

rrp->ext.choice = 2;

8294

rrp->ext.value.ptrvalue = (Pointer) trp;

8295

}

8296

}

8297

if (aa == 0 || !justTrnaText)

8298

{

8299

AddToComment (sfp, product);

8300

}

8301

}

8302

else if (rrp->type == 255

8303

&& rrp->ext.choice == 1

8304

&& (StringCmp (rrp->ext.value.ptrvalue, "ncRNA") == 0

8305

|| StringCmp (rrp->ext.value.ptrvalue, "tmRNA") == 0

8306

|| StringCmp (rrp->ext.value.ptrvalue, "misc_RNA") == 0))

8307

{

8308

gbq = FindOrAddQual (sfp, "product");

8309

gbq->val = MemFree (gbq->val);

8310

gbq->val = StringSave (product);

8311

}

8312

else

8313

{

8314

ClearRNAProduct (rrp);

8315

rrp->ext.choice = 1;

8316

rrp->ext.value.ptrvalue = StringSave (product);

8317

}

8318

}

8319

8320

8321

8322

typedef struct rnatypedlg {

8323

DIALOG_MESSAGE_BLOCK

8324

PopuP rna_type;

8325

DialoG ncrna_class;

8326

Nlm_ChangeNotifyProc change_notify;

8327

Pointer change_userdata;

8328

Boolean is_constraint;

8329

8330

} RnaTypeDlgData, PNTR RnaTypeDlgPtr;

8331

8332

8333

static void ChangeRnaTypeDlg (PopuP p)

8334

{

8335

RnaTypeDlgPtr dlg;

8336

UIEnum val;

8337

8338

dlg = (RnaTypeDlgPtr) GetObjectExtra (p);

8339

if (dlg != NULL)

8340

{

8341

if (GetEnumPopup (dlg->rna_type, rna_type_alist, &val) && val == 8)

8342

{

8343

Enable (dlg->ncrna_class);

8344

}

8345

else

8346

{

8347

Disable (dlg->ncrna_class);

8348

}

8349

if (dlg->change_notify != NULL)

8350

{

8351

(dlg->change_notify) (dlg->change_userdata);

8352

}

8353

}

8354

}

8355

8356

8357

static void PointerToRnaTypeDialog (DialoG d, Pointer data)

8358

{

8359

RnaTypeDlgPtr dlg;

8360

RnaTypePtr rtp = NULL;

8361

8362

dlg = (RnaTypeDlgPtr) GetObjectExtra (d);

8363

if (dlg == NULL) return;

8364

8365

rtp = (RnaTypePtr) data;

8366

if (rtp == NULL || rtp->rna_featdef == FEATDEF_ANY)

8367

{

8368

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 0);

8369

PointerToDialog (dlg->ncrna_class, NULL);

8370

}

8371

else

8372

{

8373

switch (rtp->rna_featdef)

8374

{

8375

case FEATDEF_preRNA:

8376

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 1);

8377

PointerToDialog (dlg->ncrna_class, NULL);

8378

break;

8379

case FEATDEF_mRNA:

8380

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 2);

8381

PointerToDialog (dlg->ncrna_class, NULL);

8382

break;

8383

case FEATDEF_tRNA:

8384

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 3);

8385

PointerToDialog (dlg->ncrna_class, NULL);

8386

break;

8387

case FEATDEF_rRNA:

8388

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 4);

8389

PointerToDialog (dlg->ncrna_class, NULL);

8390

break;

8391

case FEATDEF_scRNA:

8392

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 8);

8393

PointerToDialog (dlg->ncrna_class, "scRNA");

8394

break;

8395

case FEATDEF_snRNA:

8396

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 8);

8397

PointerToDialog (dlg->ncrna_class, "snRNA");

8398

break;

8399

case FEATDEF_snoRNA:

8400

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 8);

8401

PointerToDialog (dlg->ncrna_class, "snoRNA");

8402

break;

8403

case FEATDEF_ncRNA:

8404

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 8);

8405

PointerToDialog (dlg->ncrna_class, rtp->ncrna_class);

8406

break;

8407

case FEATDEF_tmRNA:

8408

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 9);

8409

PointerToDialog (dlg->ncrna_class, NULL);

8410

break;

8411

case FEATDEF_otherRNA:

8412

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 255);

8413

PointerToDialog (dlg->ncrna_class, NULL);

8414

break;

8415

default:

8416

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 0);

8417

PointerToDialog (dlg->ncrna_class, NULL);

8418

break;

8419

}

8420

}

8421

ChangeRnaTypeDlg (dlg->rna_type);

8422

}

8423

8424

8425

static Pointer RnaTypeDialogToPointer (DialoG d)

8426

{

8427

RnaTypeDlgPtr dlg;

8428

RnaTypePtr rtp = NULL;

8429

UIEnum val;

8430

8431

dlg = (RnaTypeDlgPtr) GetObjectExtra (d);

8432

if (dlg == NULL) return NULL;

8433

8434

if (GetEnumPopup (dlg->rna_type, rna_type_alist, &val))

8435

{

8436

rtp = (RnaTypePtr) MemNew (sizeof (RnaTypeData));

8437

rtp->rna_featdef = FEATDEF_ANY;

8438

rtp->ncrna_class = NULL;

8439

switch (val)

8440

{

8441

case 0:

8442

rtp->rna_featdef = FEATDEF_ANY;

8443

break;

8444

case 1:

8445

rtp->rna_featdef = FEATDEF_preRNA;

8446

break;

8447

case 2:

8448

rtp->rna_featdef = FEATDEF_mRNA;

8449

break;

8450

case 3:

8451

rtp->rna_featdef = FEATDEF_tRNA;

8452

break;

8453

case 4:

8454

rtp->rna_featdef = FEATDEF_rRNA;

8455

break;

8456

case 8:

8457

rtp->rna_featdef = FEATDEF_ncRNA;

8458

rtp->ncrna_class = DialogToPointer (dlg->ncrna_class);

8459

break;

8460

case 9:

8461

rtp->rna_featdef = FEATDEF_tmRNA;

8462

break;

8463

case 255:

8464

rtp->rna_featdef = FEATDEF_otherRNA;

8465

break;

8466

}

8467

}

8468

return rtp;

8469

}

8470

8471

8472

static ValNodePtr TestRnaTypeDialog (DialoG d)

8473

{

8474

RnaTypeDlgPtr dlg;

8475

ValNodePtr err_list = NULL;

8476

UIEnum val;

8477

8478

dlg = (RnaTypeDlgPtr) GetObjectExtra (d);

8479

if (dlg == NULL) return NULL;

8480

if (GetEnumPopup (dlg->rna_type, rna_type_alist, &val)) {

8481

if (val == 8) {

8482

err_list = TestDialog (dlg->ncrna_class);

8483

}

8484

} else {

8485

ValNodeAddPointer (&err_list, 0, "RNA type");

8486

}

8487

return err_list;

8488

}

8489

8490

extern DialoG RnaTypeDialog (GrouP h, Boolean is_constraint, Nlm_ChangeNotifyProc change_notify, Pointer change_userdata)

8491

{

8492

RnaTypeDlgPtr dlg;

8493

GrouP p;

8494

CharPtr title;

8495

8496

if (is_constraint) {

8497

title = "RNA Type of Feature to be Edited";

8498

} else {

8499

title = "RNA Type";

8500

}

8501

8502

p = NormalGroup (h, -1, 0, title, programFont, NULL);

8503

dlg = (RnaTypeDlgPtr) MemNew (sizeof (RnaTypeDlgData));

8504

SetObjectExtra (p, dlg, StdCleanupExtraProc);

8505

8506

dlg->dialog = (DialoG) p;

8507

dlg->todialog = PointerToRnaTypeDialog;

8508

dlg->fromdialog = RnaTypeDialogToPointer;

8509

dlg->testdialog = TestRnaTypeDialog;

8510

dlg->change_notify = change_notify;

8511

dlg->change_userdata = change_userdata;

8512

dlg->is_constraint = is_constraint;

8513

8514

dlg->rna_type = PopupList (p, TRUE, ChangeRnaTypeDlg);

8515

SetObjectExtra (dlg->rna_type, dlg, NULL);

8516

InitEnumPopup (dlg->rna_type, rna_type_alist, NULL);

8517

SetEnumPopup (dlg->rna_type, rna_type_alist, (UIEnum) 0);

8518

8519

dlg->ncrna_class = CreatencRNAClassDialog (p, is_constraint, change_notify, change_userdata);

8520

8521

AlignObjects (ALIGN_CENTER, (HANDLE) dlg->rna_type, (HANDLE) dlg->ncrna_class, NULL);

8522

8523

return (DialoG) p;

8524

}

8525

Older »