~ubuntu-branches/ubuntu/warty/ncbi-tools6/warty

static SeqEntryPtr NewFastaRead (FILE *fp, Boolean is_na, Boolean parseSeqId, Int2 *seqnumber, Int2 *segnumber, SeqIdPtr PNTR siplst, Int4 *lengthmax)

302

{

303

BioseqPtr bsp;

304

SeqEntryPtr sep = NULL;

305

SeqEntryPtr lastsep = NULL;

306

SeqEntryPtr nextsep = NULL;

307

SeqEntryPtr last = NULL;

308

CharPtr errormsg = NULL;

309

ValNodePtr head = NULL;

310

Char lastchar;

311

ObjectIdPtr oid = NULL;

312

SeqIdPtr sip;

313

SeqIdPtr siphead = NULL,

314

siptmp = NULL;

315

SeqIdPtr segsip=NULL, lastsegsip=NULL;

316

ValNodePtr vnp;

317

Int4 count;

318

Int4 lensmax = 0,

319

lens;

320

Int2 nseq = 0;

321

Int2 segcount = 0,

322

segtotal = 0,

323

324

Boolean insegset;

325

Boolean isLocalUnknownID;

326

327

SeqEntryPtr sepnuc;

328

BioseqPtr segbsp;

329

330

count = 0;

331

last = sep;

332

lastsep = NULL;

333

insegset = FALSE;

334

nextsep = FastaToSeqEntryInternal ((void *)fp, 2, NULL, is_na, &errormsg, parseSeqId, &lastchar);

335

while (nextsep != NULL || (lastchar != EOF && lastchar != NULLB && lastchar != 255)) {

336

if (nextsep != NULL) {

337

count++;

338

if (IS_Bioseq (nextsep) && nextsep->data.ptrvalue != NULL) {

339

bsp = (BioseqPtr) nextsep->data.ptrvalue;

340

if (bsp->length > lensmax)

341

lensmax = bsp->length;

342

isLocalUnknownID = FALSE;

343

sip = bsp->id;

344

if (sip != NULL && sip->choice == SEQID_LOCAL) {

345

oid = (ObjectIdPtr) sip->data.ptrvalue;

346

if (oid != NULL && oid->str != NULL) {

347

isLocalUnknownID = (Boolean) (StringICmp (oid->str, "unknown") == 0);

348

}

349

}

350

if ((! parseSeqId) || isLocalUnknownID) {

351

sip = new_local_sip (count, is_na);

352

if (sip != NULL) {

353

bsp->id = SeqIdFree (bsp->id);

354

bsp->id = sip;

355

SeqMgrReplaceInBioseqIndex (bsp);

356

}

357

}

358

j=SeqIdOrderInBioseqIdList(sip,siphead);

359

if (j > 1) {

360

siptmp = NULL;

361

if (sip != NULL && sip->choice == SEQID_LOCAL) {

362

oid = (ObjectIdPtr) sip->data.ptrvalue;

363

if (oid != NULL && oid->str != NULL) {

364

lens = MIN(StringLen(oid->str), (Int4)7);

365

oid->str[lens] = '\0';

366

}

367

}

368

siptmp = MakeNewProteinSeqId (NULL, sip);

369

if (siptmp == NULL)

370

siptmp = new_local_sip (count, is_na);

371

if (siptmp!=NULL) {

372

siptmp->next = NULL;

373

bsp->id = SeqIdFree (bsp->id);

374

bsp->id = siptmp;

375

SeqMgrReplaceInBioseqIndex (bsp);

376

sip = bsp->id;

377

}

378

}

379

siptmp = SeqIdDup (sip);

380

siphead = AddSeqId (&siphead, siptmp);

381

}

382

SeqEntryPack (nextsep);

383

if (sep != NULL) {

384

if (insegset) {

385

if (lastsep != NULL) {

386

AddSeqEntryToSeqEntry (lastsep, nextsep, TRUE);

387

segcount ++;

388

if (segcount > segtotal)

389

segtotal = segcount;

390

sepnuc = FindNucSeqEntry (lastsep);

391

if (IS_Bioseq(sepnuc)) {

392

segbsp=(BioseqPtr)sepnuc->data.ptrvalue;

393

segsip=segbsp->id;

394

if (segsip != NULL) {

395

lastsegsip = segsip;

396

}

397

}

398

}

399

else {

400

lastsep = nextsep;

401

last->next = nextsep;

402

last = nextsep;

403

segcount=1;

404

if (segcount > segtotal)

405

segtotal = segcount;

406

nseq++;

407

}

408

}

409

else {

410

last->next = nextsep;

411

last = nextsep;

412

segcount=1;

413

if (segcount > segtotal)

414

segtotal = segcount;

415

nseq++;

416

lastsegsip = sip;

417

418

}

419

}

420

else {

421

if (insegset && lastsep == NULL) {

422

lastsep = nextsep;

423

sep = nextsep;

424

last = sep;

425

segcount=1;

426

if (segcount > segtotal)

427

segtotal = segcount;

428

nseq++;

429

430

}

431

else {

432

sep = nextsep;

433

last = sep;

434

segcount=1;

435

if (segcount > segtotal)

436

segtotal = segcount;

437

nseq++;

438

lastsegsip = sip;

439

440

}

441

}

442

vnp = ValNodeNew (head);

443

if (head == NULL) {

444

head = vnp;

445

}

446

if (vnp != NULL) {

447

vnp->data.ptrvalue = errormsg;

448

errormsg = NULL;

449

}

450

} else if (lastchar == '[') {

451

insegset = TRUE;

452

lastsep = NULL;

453

} else if (lastchar == ']') {

454

insegset = FALSE;

455

}

456

nextsep = FastaToSeqEntryInternal ((void *)fp, 2, NULL, is_na, &errormsg, parseSeqId, &lastchar);

457

}

458

if (segnumber !=NULL)

459

*segnumber = segtotal;

460

if (sip!=NULL)

461

*siplst = siphead;

462

else

463

SeqIdFree (siphead);

464

if (lengthmax != NULL)

465

*lengthmax = lensmax;

466

if(seqnumber != NULL)

467

*seqnumber = nseq;

468

return sep;

469

}

470

471

static SeqEntryPtr FastaReadAdvanced (CharPtr path, Uint2 mol_type, Int2 *seqnumber, Int2 *segnumber, SeqIdPtr PNTR sip, Int4 *lengthmax)

472

{

473

Char name[PATH_MAX];

474

SeqEntryPtr sep = NULL;

475

FILE *fpin;

476

477

if (path == NULL) {

478

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

479

return NULL;

480

}

481

path = name;

482

}

483

if ( (fpin = FileOpen (path, "r")) != NULL) {

484

if (segnumber != NULL)

485

sep = NewFastaRead (fpin, (Boolean)ISA_na (mol_type), TRUE, seqnumber, segnumber, sip, lengthmax);

486

else

487

sep = NewFastaRead (fpin, (Boolean)ISA_na (mol_type), TRUE, NULL, NULL, NULL, NULL);

488

FileClose (fpin);

489

sep = make_seqentry_for_seqentry (sep);

490

}

491

return sep;

492

}

493

494

/*******************************************************************

495

***

496

*** LocalAlignsToSeqAnnotDimn

497

*** LocalAlign1ToSeqAnnotDimn

498

***

499

*************************************************************************/

500

501

static ValNodePtr get_lens_fromseqalign (SeqAlignPtr salp)

502

{

503

DenseDiagPtr ddp;

504

DenseSegPtr dsp;

505

ValNodePtr fromp = NULL;

506

Int4Ptr startp;

507

Int4 j,

508

val = (Int4)-1;

509

Int2 index;

510

Uint1 strand;

511

512

if (salp == NULL)

513

return NULL;

514

if (salp->segtype == 1)

515

{

516

ddp = (DenseDiagPtr) salp->segs;

517

if (ddp != NULL) {

518

for (index=0; index<ddp->dim; index++) {

519

startp = ddp->starts;

520

if (index > 0)

521

startp += index;

522

val = *startp + ddp->len;

523

ValNodeAddInt (&fromp, 1, (Int4)(val+1));

524

}

525

}

526

}

527

else if (salp->segtype == 2)

528

{

529

dsp = (DenseSegPtr) salp->segs;

530

if (dsp!=NULL)

531

{

532

for (index=0; index<dsp->dim; index++)

533

{

534

if ((Boolean)(dsp->strands != NULL))

535

strand = dsp->strands[index];

536

else

537

strand = Seq_strand_plus;

538

startp = dsp->starts + ((dsp->dim * dsp->numseg) - dsp->dim);

539

if (index > 0)

540

startp += index;

541

for (j = dsp->numseg-1; j >= 0; j--, startp-=dsp->dim)

542

if (*startp > -1)

543

break;

544

if (j >= 0) {

545

if (strand == Seq_strand_minus)

546

val = *startp;

547

else

548

val = *startp + dsp->lens[j] - 1;

549

ValNodeAddInt (&fromp, 1, (Int4)(val+1));

550

}

551

else

552

ValNodeAddInt (&fromp, 1, (Int4)(-1));

553

}

554

}

555

}

556

return fromp;

557

}

558

559

static SeqAnnotPtr LocalAlign1ToSeqAnnotDimn (ValNodePtr vnpal, SeqIdPtr seqsip, ValNodePtr fromp, Int2 nbseq, Int4 lens, ValNodePtr strands, Boolean trunc_emptyends)

560

{

561

SeqAnnotPtr sap1=NULL;

562

ValNodePtr tmp;

563

564

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

565

tmp = (ValNodePtr) vnpal->data.ptrvalue;

566

sap1 = LocalAlignToSeqAnnotDimn (tmp, seqsip, fromp, nbseq, lens, NULL, FALSE);

567

}

568

return sap1;

569

}

570

571

static SeqAnnotPtr LocalAlignsToSeqAnnotDimn (ValNodePtr vnpal, SeqIdPtr seqsip, ValNodePtr fromp, Int2 nbseq, Int2 nbseg, Int4 lens, ValNodePtr strands, Boolean trunc_emptyends)

572

{

573

SeqAnnotPtr sap1 = NULL,

574

sap = NULL;

575

SeqAlignPtr salphead = NULL,

576

salptmp;

577

ValNodePtr vnp,

578

tmp;

579

SeqIdPtr siplst,

580

siptmp,

581

siptmp2;

582

Int2 k1, k, j=0;

583

584

vnp = vnpal;

585

salphead = NULL;

586

while (salphead == NULL && vnp != NULL)

587

{

588

siplst=NULL;

589

siptmp = seqsip;

590

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

591

siptmp=siptmp->next;

592

for (k=0; k<nbseq; k++) {

593

siptmp2=SeqIdDup(siptmp);

594

siplst = AddSeqId (&siplst, siptmp2);

595

for (k1=0; k1<nbseg; k1++)

596

siptmp=siptmp->next;

597

}

598

tmp = (ValNodePtr) vnp->data.ptrvalue;

599

sap1 = LocalAlignToSeqAnnotDimn (tmp, siplst, fromp, nbseq, lens, NULL, FALSE);

600

if (sap1!=NULL && sap1->data!=NULL)

601

salphead = (SeqAlignPtr) sap1->data;

602

vnp = vnp->next;

603

j++;

604

}

605

if (fromp!=NULL)

606

fromp = ValNodeFree (fromp);

607

salptmp = salphead;

608

while (vnp!=NULL)

609

{

610

611

fromp = get_lens_fromseqalign (salptmp);

612

613

siplst=NULL;

614

siptmp = seqsip;

615

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

616

siptmp=siptmp->next;

617

for (k=0; k<nbseq; k++) {

618

siptmp2=SeqIdDup(siptmp);

619

siplst = AddSeqId (&siplst, siptmp2);

620

for (k1=0; k1<nbseg && siptmp!=NULL; k1++)

621

siptmp=siptmp->next;

622

}

623

tmp = (ValNodePtr) vnp->data.ptrvalue;

624

sap = LocalAlignToSeqAnnotDimn (tmp, siplst, fromp, nbseq, lens, NULL, FALSE);

625

if (sap!=NULL && sap->data!=NULL) {

626

salptmp->next = (SeqAlignPtr)sap->data;

627

salptmp = salptmp->next;

628

}

629

vnp = vnp->next;

630

if (fromp!=NULL)

631

fromp = ValNodeFree (fromp);

632

j++;

633

}

634

return sap1;

635

}

636

637

/*****************************************************

638

*** GapFastaRead

639

*** 1) reads the sequences as FASTA: FastaReadAdvanced

640

*** 2) reads the sequence text with the gaps (-): ReadAlignmentToStrings

641

*** the max length allocated for the char array

642

*** that is the max length of the sequences plus a 1/2 of gaps.

643

***

644

*** ConvertPaupToFastaGap

645

***

646

******************************************************/

647

static ValNodePtr ReadAlignmentToStrings (CharPtr path, Int4 length, Int2 segnumber)

648

{

649

Char name[PATH_MAX];

650

FILE *fp;

651

ValNodePtr vnpal, tmp, vnp;

652

CharPtr str = NULL;

653

CharPtr strp,

654

seqstr;

655

Int4 strlens,

656

lmax=0,

657

lgseq=0;

658

Int2 inseg = 0;

659

Boolean insegb = FALSE;

660

Boolean startp;

661

662

663

Int2 j = 0;

664

Int2 nseq = 0;

665

666

if (path == NULL) {

667

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

668

return NULL;

669

}

670

path = name;

671

}

672

vnpal = ValNodeNew (NULL);

673

tmp = vnpal;

674

for (j=1; j<segnumber; j++) {

675

vnp = ValNodeNew (NULL);

676

tmp->next = vnp;

677

tmp = tmp->next;

678

}

679

if ( (fp = FileOpen (path, "r")) == NULL) {

680

ValNodeFree (vnpal);

681

return NULL;

682

}

683

vnp=NULL;

684

lmax = length + length/2;

685

str = FGetLine (fp);

686

if (str) {

687

strp = str;

688

while (*strp == ' ' && *strp!='\0' && *strp!='\n')

689

strp++;

690

if (*strp!='\0' && *strp!='\n')

691

strlens = StringLen (strp);

692

else

693

str=NULL; /*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/

694

}

695

while (str)

696

{

697

if (strlens > 0) {

698

if (*strp == '>') {

699

if (!insegb) {

700

vnp = vnpal;

701

}

702

else {

703

inseg++;

704

if (inseg==1)

705

vnp = vnpal;

706

else

707

vnp = vnp->next;

708

}

709

startp = FALSE;

710

}

711

else if (StringStr(strp, "[")!= NULL) {

712

if (vnp!=NULL) {

713

}

714

insegb = TRUE;

715

inseg = 0;

716

startp= FALSE;

717

}

718

else if (StringStr(strp, "]")!= NULL) {

719

insegb = FALSE;

720

inseg = 0;

721

startp= FALSE;

722

}

723

else {

724

if (!startp) {

725

seqstr=(CharPtr)MemNew((size_t)((lmax + 1) * sizeof(Char)));

726

for (strlens=0; strlens<lmax; strlens++)

727

seqstr[strlens] = ' ';

728

if (vnp) {

729

if (vnp->data.ptrvalue==NULL) {

730

tmp = NULL;

731

ValNodeAddPointer (&tmp, 0, (Pointer)seqstr);

732

vnp->data.ptrvalue = (Pointer) tmp;

733

} else {

734

tmp = (ValNodePtr)vnp->data.ptrvalue;

735

ValNodeAddPointer (&tmp, 0, (Pointer)seqstr);

736

}

737

}

738

lgseq = 0;

739

startp = TRUE;

740

}

741

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

742

{

743

if (strp[j]=='\n' || strp[j]=='\0' || strp[j]=='\r' )

744

break;

745

strp[j] = TO_UPPER(strp[j]);

746

if (StringChr("ABCDEFGHIKLMNPQRSTUVWXYZ-*", strp[j]) != NULL) {

747

seqstr [lgseq] = strp[j];

748

lgseq++;

749

}

750

}

751

seqstr [lgseq] = '\0';

752

}

753

}

754

MemFree (str);

755

str = FGetLine(fp);

756

if (str) {

757

strp = str;

758

while (*strp == ' ' && *strp!='\0' && *strp!='\n')

759

strp++;

760

if (*strp!='\0' && *strp!='\n')

761

strlens = StringLen (strp);

762

else

763

str=NULL; /****!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/

764

}

765

}

766

if (str)

767

MemFree(str);

768

fclose (fp);

769

return vnpal;

770

}

771

772

static SeqEntryPtr GapFastaRead (CharPtr path, Uint2 mol_type)

773

{

774

Char name[PATH_MAX];

775

SeqAnnotPtr sap = NULL;

776

SeqEntryPtr sep = NULL;

777

ValNodePtr vnp = NULL;

778

SeqIdPtr sip = NULL,

779

siptmp = NULL;

780

Int4 lmax;

781

Int2 nseq = 0,

782

seqnumber = 0,

783

segnumber;

784

CharPtr str;

785

786

if (path == NULL) {

787

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

788

return NULL;

789

}

790

path = name;

791

}

792

sep = FastaReadAdvanced (path, mol_type, &seqnumber, &segnumber, &sip, &lmax);

793

if (sep == NULL) {

794

return NULL;

795

}

796

nseq=0;

797

for (siptmp=sip; siptmp!=NULL; siptmp=siptmp->next) {

798

nseq++;

799

}

800

if (nseq != seqnumber*segnumber) {

801

ErrPostEx (SEV_ERROR, 0, 0, "Every sequences should have a sequence ID");

802

sep = SeqEntryFree (sep);

803

}

804

str=matching_seqid (sip);

805

if (str) {

806

ErrPostEx (SEV_ERROR, 0, 0, "The submission contains several sequences with the same name \"%s\"", str);

807

MemFree (str);

808

sep = SeqEntryFree (sep);

809

}

810

else {

811

vnp = ReadAlignmentToStrings (path, lmax, segnumber);

812

if (segnumber > 1)

813

sap=LocalAlignsToSeqAnnotDimn(vnp,sip,NULL,seqnumber,segnumber, 0, NULL, FALSE);

814

else

815

sap=LocalAlign1ToSeqAnnotDimn (vnp, sip, NULL, seqnumber, 0, NULL, FALSE);

816

if (sap)

817

SeqAlignAddInSeqEntry (sep, sap);

818

}

819

if (vnp)

820

ValNodeFree (vnp);

821

SeqIdFree (sip);

822

return sep;

823

}

824

825

/********************************************************************/

826

static Boolean has_extrachar (CharPtr str, Char missingchar, Char gapchar)

827

{

828

Int2 j;

829

Boolean ret = FALSE;

830

831

if (str==NULL)

832

return TRUE;

833

if (*str=='\0' || *str=='\n')

834

return TRUE;

835

for (j=0; j<StrLen(str); j++) {

836

if (str[j]!='\n' && str[j]!='\0' && str[j]!='\r'

837

&& str[j]!=' '

838

&& str[j]!='!')

839

{

840

if (!isdigit(str[j]))

841

{

842

if ((StringChr ("ABCDGHKMNRSTUVWY", str[j])) == NULL &&

843

(StringChr ("abcdghkmnrstuvwy", str[j])) == NULL &&

844

str[j]!=gapchar && str[j] != missingchar &&

845

str[j]!='[' && str[j]!=']') {

846

ret = TRUE;

847

break;

848

}

849

}

850

}

851

}

852

return ret;

853

}

854

855

/********************************************************************/

856

static Char nexustoseq (Char car, Char missingchar, Char gapchar)

857

{

858

if (car == ':')

859

return ('-');

860

if (car == '.')

861

return ('-');

862

if (car == missingchar)

863

return ('N');

864

if (car == gapchar)

865

return ('-');

866

if (isalpha (car))

867

return car;

868

return ('!');

869

}

870

871

/********************************************************************/

872

static Boolean ConvertPaupToFastaGap (CharPtr path, CharPtr tmpfile)

873

{

874

FILE *fp, *fpout;

875

CharPtr tmp;

876

CharPtr str = NULL;

877

CharPtr str2;

878

Char gapchar = '-';

879

Char missingchar = '?';

880

Char car;

881

Int4 strlens;

882

Int4 lg_seq = 0;

883

Int2 n_seq = 0;

884

Int2 n_tmp = 0;

885

Int4 j, j1,

886

887

k1=0;

888

Boolean first_line;

889

890

if ( (fp = FileOpen (path, "r")) == NULL) {

891

return FALSE;

892

}

893

str = FGetLine (fp);

894

while (str) {

895

if (! stringhasnotext (str)) {

896

if (StringLen (str) > 0 && str [0] != '>')

897

break;

898

}

899

MemFree (str);

900

str = FGetLine (fp);

901

}

902

if (!str) {

903

FileClose(fp);

904

return FALSE;

905

}

906

while (str) {

907

tmp = StringStr(str, "INTERLEAVE");

908

if (tmp == NULL)

909

tmp = StringStr(str, "interleave");

910

if (tmp != NULL) {

911

n_seq = 0;

912

lg_seq= 0;

913

ErrPostEx (SEV_ERROR, 0, 0, "This is a NEXUS interleave format");

914

break;

915

}

916

tmp = StringStr(str, "GAP=");

917

if (tmp == NULL)

918

tmp = StringStr(str, "gap=");

919

if (tmp != NULL) {

920

while (*tmp!='\0' && *tmp!='\n' && *tmp!='=')

921

tmp++;

922

if (*tmp!='\0' && *tmp!='\n')

923

tmp++;

924

while (*tmp!='\0' && *tmp!='\n' && *tmp==' ')

925

tmp++;

926

if (*tmp!='\0' && *tmp!='\n')

927

gapchar = *tmp;

928

}

929

tmp = StringStr(str, "MISSING=");

930

if (tmp == NULL)

931

tmp = StringStr(str, "missing=");

932

if (tmp != NULL) {

933

while (*tmp!='\0' && *tmp!='\n' && *tmp!='=')

934

tmp++;

935

if (*tmp!='\0' && *tmp!='\n')

936

tmp++;

937

while (*tmp!='\0' && *tmp!='\n' && *tmp==' ')

938

tmp++;

939

if (*tmp!='\0' && *tmp!='\n')

940

missingchar = *tmp;

941

}

942

if (n_seq == 0) {

943

tmp = StringStr(str, "NTAX");

944

if (tmp == NULL)

945

tmp = StringStr(str, "ntax");

946

if (tmp != NULL) {

947

while (*tmp!='\0' && *tmp!='\n' && !isdigit (*tmp))

948

tmp++;

949

if (*tmp!='\0' && *tmp!='\n')

950

n_seq = (Int2) atoi(tmp);

951

}

952

}

953

if (lg_seq == 0) {

954

tmp = StringStr(str, "NCHAR");

955

if (tmp == NULL)

956

tmp = StringStr(str, "nchar");

957

if (tmp != NULL) {

958

while (*tmp!='\0' && !isdigit (*tmp))

959

tmp++;

960

if (*tmp!='\0')

961

lg_seq = (Int4) atol(tmp);

962

}

963

}

964

tmp = StringStr(str, "MATRIX");

965

if (tmp == NULL)

966

tmp = StringStr(str, "matrix");

967

if (tmp!=NULL) {

968

break;

969

}

970

MemFree (str);

971

str = FGetLine (fp);

972

}

973

if (n_seq == 0 || lg_seq == -1) {

974

FileClose(fp);

975

return FALSE;

976

}

977

while (str) {

978

tmp = StringStr(str, "MATRIX");

979

if (tmp == NULL)

980

tmp = StringStr(str, "matrix");

981

if (tmp != NULL)

982

break;

983

MemFree (str);

984

str = FGetLine (fp);

985

}

986

if (!str) {

987

FileClose(fp);

988

return FALSE;

989

}

990

MemFree (str);

991

if ( (fpout = FileOpen (tmpfile, "w")) == NULL) {

992

FileClose(fp);

993

return FALSE;

994

}

995

str = FGetLine (fp);

996

first_line = TRUE;

997

n_tmp = 0;

998

k=0;

999

while (str) {

1000

strlens = StringLen (str);

1001

if (strlens > 0) {

1002

str2 = (CharPtr)MemNew((size_t)((strlens+4) * sizeof(Char)));

1003

if (str[0] == ';' || (tmp = StringStr(str, "end;"))!=NULL || (tmp = StringStr(str, "END;"))!=NULL || (tmp = StringStr(str, "gap data"))!=NULL)

1004

break;

1005

if (has_extrachar (str, missingchar, gapchar)) {

1006

if (strlens ==1) {

1007

first_line = FALSE;

1008

str[0]='\0';

1009

strlens = 0;

1010

}

1011

else

1012

first_line = TRUE;

1013

}

1014

j1=j=0;

1015

while (j < strlens)

1016

{

1017

if (str[j]=='\0' || str[j] == '\n' || str[j] == '\r' ) {

1018

str[j1]='\0';

1019

break;

1020

}

1021

if (str[j]=='[') {

1022

while (str[j]!='\0' && str[j]!='\n' && j < strlens && str[j]!=']')

1023

j++;

1024

}

1025

if (j < strlens)

1026

{

1027

if (!first_line) {

1028

car = nexustoseq (str[j], missingchar, gapchar);

1029

if (car != '\0' && car != '!') {

1030

str[j1] = car;

1031

j1++;

1032

}

1033

j++;

1034

}

1035

else if (first_line) {

1036

if (str[j]!=' ') {

1037

str[j1] = str[j];

1038

j1++;

1039

j++;

1040

}

1041

else {

1042

while (str[j] == ' ')

1043

j++;

1044

k1=0;

1045

while (str[j]!='\0' && str[j]!='\n' && j < strlens) {

1046

if (str[j]=='[') {

1047

while (str[j]!='\0' && str[j]!='\n' && j < strlens && str[j]!=']')

1048

j++;

1049

}

1050

if (j<strlens) {

1051

car = nexustoseq (str[j], missingchar, gapchar);

1052

if (car != '\0' && car != '!') {

1053

str2[k1] = car;

1054

k1++;

1055

}

1056

str[j] = ' ';

1057

j++;

1058

}

1059

}

1060

if (k1>0)

1061

str2[k1] = '\0';

1062

}

1063

}

1064

}

1065

}

1066

str[j1]='\0';

1067

strlens = StringLen (str);

1068

if (strlens > 0 && !stringhasnocharplus (str)) {

1069

if (!first_line && has_extrachar (str, missingchar, gapchar)) {

1070

first_line = TRUE;

1071

}

1072

if (first_line) {

1073

if (strlens > 1) {

1074

fprintf(fpout, ">%s\n", str);

1075

first_line = FALSE;

1076

k=0;

1077

n_tmp++;

1078

if (k1 > 0) {

1079

fprintf(fpout, "%s\n", str2);

1080

k1 = 0;

1081

k += StringLen (str2);

1082

}

1083

}

1084

}

1085

else {

1086

fprintf(fpout, "%s\n", str);

1087

k += strlens;

1088

if (k >= lg_seq) {

1089

if (n_tmp == n_seq)

1090

break;

1091

first_line = TRUE;

1092

}

1093

}

1094

}

1095

MemFree(str2);

1096

str2=NULL;

1097

}

1098

k1=0;

1099

MemFree (str);

1100

str = FGetLine (fp);

1101

}

1102

if (str)

1103

MemFree (str);

1104

FileClose(fp);

1105

fprintf(fpout, "\n");

1106

FileClose(fpout);

1107

return TRUE;

1108

}

1109

1110

static ValNodePtr SequenceMacawRead (CharPtr path, Int2 n_seq)

1111

{

1112

FILE *fp;

1113

ValNodePtr vnp, seqvnp;

1114

Char lenstr[8];

1115

CharPtr seq,

1116

str = NULL,

1117

tmp;

1118

Int4 lens = 0;

1119

Int2 j;

1120

Boolean worksheet=FALSE;

1121

1122

if ( (fp = FileOpen (path, "r")) == NULL) {

1123

return FALSE;

1124

}

1125

str = FGetLine (fp);

1126

while (!worksheet)

1127

{

1128

tmp = StringStr(str, "worksheet");

1129

if (tmp) {

1130

worksheet=TRUE;

1131

break;

1132

}

1133

MemFree (str);

1134

str = FGetLine (fp);

1135

}

1136

if (worksheet)

1137

{

1138

while (str) {

1139

tmp = StringStr(str, "num-cols");

1140

if (tmp) {

1141

while (*tmp!=' ' && *tmp!='\0' && *tmp!='\n')

1142

tmp++;

1143

while (!isdigit (*tmp) && *tmp!='\0' && *tmp!='\n')

1144

tmp++;

1145

j=0;

1146

lenstr[0]='\0';

1147

while (isdigit (*tmp) && *tmp!='\0' && *tmp!='\n') {

1148

lenstr[j]=*tmp;

1149

tmp++;

1150

j++;

1151

}

1152

lens = (Int4) atol (lenstr);

1153

break;

1154

}

1155

MemFree (str);

1156

str = FGetLine (fp);

1157

}

1158

if (lens > 0)

1159

{

1160

seqvnp = new_sequence_vectors (n_seq, lens);

1161

vnp = seqvnp;

1162

while (str) {

1163

tmp = StringStr(str, "gap-seq");

1164

if (tmp) {

1165

while (*tmp!='"' && *tmp!='\0' && *tmp!='\n')

1166

tmp++;

1167

if (*tmp=='"')

1168

{

1169

tmp++;

1170

seq = (CharPtr)vnp->data.ptrvalue;

1171

j=0;

1172

seq[0]='\0';

1173

while (*tmp!='"')

1174

{

1175

if (*tmp=='\0' || *tmp=='\n') {

1176

MemFree (str);

1177

str = FGetLine (fp);

1178

tmp = str;

1179

}

1180

else {

1181

seq[j] = *tmp;

1182

tmp++;

1183

j++;

1184

}

1185

}

1186

if (*tmp=='"')

1187

vnp=vnp->next;

1188

}

1189

}

1190

if (str)

1191

MemFree (str);

1192

str = FGetLine (fp);

1193

}

1194

}

1195

}

1196

if (str)

1197

MemFree (str);

1198

FileClose (fp);

1199

return seqvnp;

1200

}

1201

1202

static SeqIdPtr NameMacawRead (CharPtr path)

1203

{

1204

FILE *fp;

1205

Char name [255];

1206

CharPtr str = NULL,

1207

tmp;

1208

SeqIdPtr siphead=NULL,

1209

sip;

1210

Int2 j;

1211

1212

if ( (fp = FileOpen (path, "r")) == NULL) {

1213

return FALSE;

1214

}

1215

str = FGetLine (fp);

1216

while (str) {

1217

tmp = StringStr(str, "name");

1218

if (tmp) {

1219

while (*tmp!='"' && *tmp!='\0' && *tmp!='\n')

1220

tmp++;

1221

if (*tmp=='"')

1222

{

1223

tmp++;

1224

j=0;

1225

name[0]='\0';

1226

while (*tmp!='"' && *tmp!='\0' && *tmp!='\n' && j<254) {

1227

name[j] = *tmp;

1228

tmp++;

1229

j++;

1230

}

1231

name[j]='\0';

1232

if (StringLen(name) > 0) {

1233

sip = MakeSeqID (name);

1234

if (sip) {

1235

siphead = AddSeqId (&siphead, sip);

1236

}

1237

}

1238

}

1239

}

1240

if (str)

1241

MemFree (str);

1242

str = FGetLine (fp);

1243

tmp = StringStr(str, "worksheet");

1244

if (tmp) {

1245

break;

1246

}

1247

}

1248

if (str)

1249

MemFree (str);

1250

return siphead;

1251

}

1252

1253

static SeqEntryPtr MacawRead (CharPtr path, Uint1 mol_type, SeqIdPtr seqid, Boolean save_seqentry, Boolean save_sap)

1254

{

1255

SeqEntryPtr sep = NULL;

1256

ValNodePtr seqvnp=NULL,

1257

vnp = NULL;

1258

SeqAnnotPtr sap;

1259

SeqIdPtr sip;

1260

Int4 n_seq=0;

1261

CharPtr str;

1262

1263

if (seqid == NULL)

1264

seqid = NameMacawRead (path);

1265

if (seqid == NULL)

1266

return NULL;

1267

str=matching_seqid (seqid);

1268

if (str)

1269

{

1270

ErrPostEx (SEV_ERROR, 0, 0, "The submission contains several sequences with the same name \"%s\"", str);

1271

MemFree (str);

1272

SeqIdFree (seqid);

1273

return NULL;

1274

}

1275

for (sip=seqid; sip!=NULL; sip=sip->next)

1276

n_seq++;

1277

seqvnp = SequenceMacawRead (path, n_seq);

1278

if (seqvnp == NULL)

1279

{

1280

SeqIdFree (seqid);

1281

return NULL;

1282

}

1283

if ( save_sap )

1284

sap = LocalAlignToSeqAnnotDimn (seqvnp, seqid, NULL, n_seq, 0, NULL, FALSE);

1285

if ( save_seqentry )

1286

sep = strings_to_seqentry (seqvnp, mol_type, seqid, sap);

1287

ValNodeFree (seqvnp);

1288

SeqIdFree (seqid);

1289

return sep;

1290

}

1291

1292

/*******************************************************

1293

*** ReadAlignmentFunc

1294

*** called for PHYLIP, NEXUS interleave formats

1295

*** calls ReadLocalAlign

1296

*** ReadLocalName

1297

*** LocalAlignToSeqAnnotDimn

1298

*** returns a SeqEntryPtr sep_list including a SeqAnnotPtr

1299

***

1300

**********************************************************/

1301

static Boolean seq_line (CharPtr str)

1302

{

1303

CharPtr str2;

1304

Int4 lens;

1305

Int4 val1,

1306

val2,

1307

1308

1309

if (str != NULL)

1310

{

1311

str2 = StringSave (str);

1312

lens = StringLen(str2);

1313

val1 = 0;

1314

val2 = 0;

1315

for (j = lens; j > 0; j--)

1316

{

1317

str2[j] = TO_UPPER(str2[j]);

1318

if (str2[j] >= 'A' && str2[j] <= 'Z')

1319

{

1320

val1++;

1321

if (str2[j]=='A' || str2[j]=='C' || str2[j]=='T' ||

1322

str2[j]=='G' || str2[j]=='N' || str2[j]=='U')

1323

val2++;

1324

}

1325

}

1326

MemFree(str2);

1327

if (val2 > (2*val1/3))

1328

return TRUE;

1329

}

1330

return FALSE;

1331

}

1332

1333

static Boolean seq_char (Char car, Char missingchar, Char gapchar)

1334

{

1335

if (car == 'A') return TRUE;

1336

if (car == 'T') return TRUE;

1337

if (car == 'G') return TRUE;

1338

if (car == 'C') return TRUE;

1339

if (car == 'U') return TRUE;

1340

if (car == 'N') return TRUE;

1341

if (car == 'a') return TRUE;

1342

if (car == 't') return TRUE;

1343

if (car == 'g') return TRUE;

1344

if (car == 'c') return TRUE;

1345

if (car == 'u') return TRUE;

1346

if (car == 'n') return TRUE;

1347

if (car == missingchar) return TRUE;

1348

if (car == gapchar) return TRUE;

1349

if (car == '*') return TRUE;

1350

return FALSE;

1351

}

1352

1353

static Boolean seqa_char (Char car, Char missingchar, Char gapchar)

1354

{

1355

if (car >= 'A' && car <= 'Z') return TRUE;

1356

if (car >= 'a' && car <= 'z') return TRUE;

1357

if (car == missingchar) return TRUE;

1358

if (car == gapchar) return TRUE;

1359

if (car == '*') return TRUE;

1360

return FALSE;

1361

}

1362

1363

1364

static ValNodePtr ReadLocalAlign (CharPtr path, Int2 align_format, Int2 n_seq, Int2 *offset, Int2 *offset_line)

1365

1366

{

1367

FILE *fp;

1368

ValNodePtr seqvnp = NULL, vnp;

1369

CharPtr tmp,

1370

tmp1;

1371

CharPtr str = NULL;

1372

Int4 PNTR lgseq;

1373

Int4 lmax;

1374

Int4 strlens;

1375

Int2 i_seq, j;

1376

Int2 leftmargin;

1377

Int2 top_lines=0;

1378

Int4 lg_seq = 0;

1379

int val1;

1380

long val2;

1381

Boolean found_seq;

1382

Boolean first;

1383

Char gapchar = '-';

1384

Char missingchar = '?';

1385

CharPtr ptr;

1386

1387

if ( (fp = FileOpen (path, "r")) == NULL) {

1388

return NULL;

1389

}

1390

str = FGetLine (fp);

1391

while (str) {

1392

if (! stringhasnotext (str)) {

1393

if (StringLen (str) > 0 && str [0] != '>')

1394

break;

1395

}

1396

top_lines++;

1397

if (str)

1398

MemFree (str);

1399

str = FGetLine (fp);

1400

}

1401

if (align_format == SALSAA_GCG){

1402

n_seq = 1;

1403

if (str)

1404

MemFree (str);

1405

str = FGetLine (fp);

1406

while (str) {

1407

n_seq++;

1408

MemFree (str);

1409

str = FGetLine (fp);

1410

}

1411

FileClose(fp);

1412

fp = FileOpen (path, "r");

1413

str = FGetLine (fp);

1414

while (str) {

1415

if (! stringhasnotext (str)) {

1416

if (StringLen (str) > 0 && str [0] != '>')

1417

break;

1418

}

1419

if (str)

1420

MemFree (str);

1421

str = FGetLine (fp);

1422

}

1423

leftmargin = SALSAA_GCG;

1424

}

1425

else if (align_format == SALSA_NEXUS) {

1426

found_seq = FALSE;

1427

lg_seq = 0;

1428

n_seq = 0;

1429

while (str) {

1430

/* the following break statement bypassed sequence reading */

1431

1432

tmp = StringStr(str, "MATRIX");

1433

if (tmp == NULL)

1434

tmp = StringStr(str, "matrix");

1435

if (tmp != NULL) {

1436

break;

1437

}

1438

1439

if (n_seq == 0) {

1440

tmp = StringStr(str, "NTAX");

1441

if (tmp == NULL)

1442

tmp = StringStr(str, "ntax");

1443

if (tmp != NULL) {

1444

while (tmp!='\0' && !isdigit (*tmp))

1445

tmp++;

1446

if (tmp!='\0')

1447

n_seq = (Int2) atoi(tmp);

1448

}

1449

}

1450

if (lg_seq == 0) {

1451

tmp = StringStr(str, "NCHAR");

1452

if (tmp == NULL)

1453

tmp = StringStr(str, "nchar");

1454

if (tmp != NULL) {

1455

while (tmp!='\0' && !isdigit (*tmp))

1456

tmp++;

1457

if (tmp!='\0')

1458

lg_seq = (Int4) atol(tmp);

1459

}

1460

}

1461

tmp = StringStr(str, "GAP=");

1462

if (tmp == NULL)

1463

tmp = StringStr(str, "gap=");

1464

if (tmp != NULL) {

1465

while (*tmp!='\0' && *tmp!='\n' && *tmp!='=')

1466

tmp++;

1467

if (*tmp!='\0' && *tmp!='\n')

1468

tmp++;

1469

while (*tmp!='\0' && *tmp!='\n' && *tmp==' ')

1470

tmp++;

1471

if (*tmp!='\0' && *tmp!='\n')

1472

gapchar = *tmp;

1473

}

1474

tmp = StringStr(str, "MISSING=");

1475

if (tmp == NULL)

1476

tmp = StringStr(str, "missing=");

1477

if (tmp != NULL) {

1478

while (*tmp!='\0' && *tmp!='\n' && *tmp!='=')

1479

tmp++;

1480

if (*tmp!='\0' && *tmp!='\n')

1481

tmp++;

1482

while (*tmp!='\0' && *tmp!='\n' && *tmp==' ')

1483

tmp++;

1484

if (*tmp!='\0' && *tmp!='\n')

1485

missingchar = *tmp;

1486

}

1487

if (n_seq>0 && lg_seq>-1 && seq_line (str)) {

1488

if (seq_char(str[0], missingchar, gapchar)

1489

&& seq_char(str[1], missingchar, gapchar)

1490

&& seq_char(str[2], missingchar, gapchar)

1491

&& seq_char(str[3], missingchar, gapchar)

1492

&& seq_char(str[4], missingchar, gapchar)

1493

&& seq_char(str[5], missingchar, gapchar)) {

1494

leftmargin = 0;

1495

found_seq = TRUE;

1496

break;

1497

}

1498

for (leftmargin = 0; leftmargin<MAXSTR-1; leftmargin++) {

1499

if (str[leftmargin] == ' '

1500

&& seq_char(str[leftmargin+1], missingchar, gapchar)) {

1501

found_seq = TRUE;

1502

break;

1503

}

1504

}

1505

break;

1506

}

1507

top_lines++;

1508

if (str)

1509

MemFree (str);

1510

str = FGetLine (fp);

1511

}

1512

if (!found_seq)

1513

n_seq = 0;

1514

else

1515

leftmargin++;

1516

} else if (align_format == SALSAA_NEXUS)

1517

{

1518

found_seq = FALSE;

1519

lg_seq = 0;

1520

n_seq = 0;

1521

while (str) {

1522

/* the following break statement bypassed sequence reading */

1523

1524

tmp = StringStr(str, "MATRIX");

1525

if (tmp == NULL)

1526

tmp = StringStr(str, "matrix");

1527

if (tmp != NULL) {

1528

break;

1529

}

1530

1531

if (n_seq == 0) {

1532

tmp = StringStr(str, "NTAX");

1533

if (tmp == NULL)

1534

tmp = StringStr(str, "ntax");

1535

if (tmp != NULL) {

1536

while (tmp!='\0' && !isdigit (*tmp))

1537

tmp++;

1538

if (tmp!='\0')

1539

n_seq = (Int2) atoi(tmp);

1540

}

1541

}

1542

if (lg_seq == 0) {

1543

tmp = StringStr(str, "NCHAR");

1544

if (tmp == NULL)

1545

tmp = StringStr(str, "nchar");

1546

if (tmp != NULL) {

1547

while (tmp!='\0' && !isdigit (*tmp))

1548

tmp++;

1549

if (tmp!='\0')

1550

lg_seq = (Int4) atol(tmp);

1551

}

1552

}

1553

tmp = StringStr(str, "GAP=");

1554

if (tmp == NULL)

1555

tmp = StringStr(str, "gap=");

1556

if (tmp != NULL) {

1557

while (*tmp!='\0' && *tmp!='\n' && *tmp!='=')

1558

tmp++;

1559

if (*tmp!='\0' && *tmp!='\n')

1560

tmp++;

1561

while (*tmp!='\0' && *tmp!='\n' && *tmp==' ')

1562

tmp++;

1563

if (*tmp!='\0' && *tmp!='\n')

1564

gapchar = *tmp;

1565

}

1566

tmp = StringStr(str, "MISSING=");

1567

if (tmp == NULL)

1568

tmp = StringStr(str, "missing=");

1569

if (tmp != NULL) {

1570

while (*tmp!='\0' && *tmp!='\n' && *tmp!='=')

1571

tmp++;

1572

if (*tmp!='\0' && *tmp!='\n')

1573

tmp++;

1574

while (*tmp!='\0' && *tmp!='\n' && *tmp==' ')

1575

tmp++;

1576

if (*tmp!='\0' && *tmp!='\n')

1577

missingchar = *tmp;

1578

}

1579

if (n_seq>0 && lg_seq>-1 && seq_line (str)) {

1580

if (seqa_char(str[0], missingchar, gapchar)

1581

&& seqa_char(str[1], missingchar, gapchar)

1582

&& seqa_char(str[2], missingchar, gapchar)

1583

&& seqa_char(str[3], missingchar, gapchar)

1584

&& seqa_char(str[4], missingchar, gapchar)

1585

&& seqa_char(str[5], missingchar, gapchar)) {

1586

leftmargin = 0;

1587

found_seq = TRUE;

1588

break;

1589

}

1590

for (leftmargin = 0; leftmargin<MAXSTR-1; leftmargin++) {

1591

if (str[leftmargin] == ' '

1592

&& seqa_char(str[leftmargin+1], missingchar, gapchar)) {

1593

found_seq = TRUE;

1594

break;

1595

}

1596

}

1597

break;

1598

}

1599

top_lines++;

1600

if (str)

1601

MemFree (str);

1602

str = FGetLine (fp);

1603

}

1604

if (!found_seq)

1605

n_seq = 0;

1606

else

1607

leftmargin++;

1608

}

1609

else if (align_format == SALSA_PHYLIP || align_format == SALSAA_PHYLIP) {

1610

if (sscanf (str, "%d %ld", &val1, &val2) == 2) {

1611

n_seq = (Int2) val1;

1612

lg_seq = (Int4) val2;

1613

}

1614

if (str)

1615

MemFree (str);

1616

str = FGetLine (fp);

1617

leftmargin = SALSA_PHYLIP_MARGIN;

1618

top_lines++;

1619

}

1620

else if (align_format == SALSA_CLUSTALV) {

1621

if (n_seq == 0) {

1622

FileClose(fp);

1623

return NULL;

1624

}

1625

for ( j =0; j < 4; j++) {

1626

if (str)

1627

MemFree (str);

1628

str = FGetLine (fp);

1629

top_lines++;

1630

}

1631

leftmargin = SALSA_CLUSTALV_MARGIN;

1632

}

1633

else {

1634

ErrPostEx (SEV_ERROR, 0, 0, "We do not support this format yet");

1635

return NULL;

1636

}

1637

if (n_seq == 0) {

1638

FileClose(fp);

1639

return NULL;

1640

}

1641

if (lg_seq == 0)

1642

lmax = LENGTHMAX;

1643

else

1644

lmax = lg_seq;

1645

1646

*offset = leftmargin;

1647

seqvnp = new_sequence_vectors (n_seq, lmax);

1648

1649

lgseq = (Int4Ptr) MemNew((size_t) ((n_seq + 1) * sizeof(Int4)));

1650

for (j = 0; j < n_seq; j++) lgseq [j] = 0;

1651

1652

tmp1 = (CharPtr) seqvnp->data.ptrvalue;

1653

i_seq = 0;

1654

vnp = seqvnp;

1655

first = TRUE;

1656

while (str)

1657

{

1658

ptr = StringChr (str, '[');

1659

if (ptr != NULL) {

1660

*ptr = '\0';

1661

}

1662

strlens = StringLen (str);

1663

if (strlens > 0) {

1664

if (str[0] == ';' || (tmp = StringStr(str, "end;"))!=NULL || (tmp = StringStr(str, "END;"))!=NULL || (tmp = StringStr(str, "gap data"))!=NULL)

1665

break;

1666

if (! stringhasnocharplus (str) && str[0]!='>')

1667

{

1668

tmp = (CharPtr) vnp->data.ptrvalue;

1669

for (j = leftmargin; j < strlens && lgseq [i_seq] <= lmax; j++)

1670

{

1671

if (str[j] == '\n' || str[j] == '\r' ) break;

1672

str[j] = TO_UPPER (str[j]);

1673

if (str[j] == gapchar)

1674

str[j] = '-';

1675

else if (str[j] == ':')

1676

str[j] = '-';

1677

else if (str[j] == '.')

1678

{

1679

if (align_format == SALSA_PHYLIP && i_seq != 0)

1680

{

1681

/**

1682

if (tmp1[])

1683

str [j]= tmp1[lgseq[i_seq]];

1684

else

1685

**/

1686

str [j] = '-';

1687

}

1688

else

1689

str[j] = '-';

1690

}

1691

else if (str[j] == missingchar)

1692

str[j] = '-';

1693

if ((str[j] >= 'A' && str[j] <= 'Z') || str[j]=='*' || str[j] == '-') {

1694

tmp [lgseq[i_seq]] = str[j];

1695

++lgseq [i_seq];

1696

}

1697

}

1698

++i_seq;

1699

if (i_seq == n_seq) {

1700

i_seq = 0;

1701

vnp = seqvnp;

1702

if (align_format == SALSA_PHYLIP && first) {

1703

leftmargin=0;

1704

first = FALSE;

1705

}

1706

}

1707

else vnp = vnp->next;

1708

}

1709

}

1710

if (str)

1711

MemFree (str);

1712

str = FGetLine (fp);

1713

}

1714

if (str)

1715

MemFree (str);

1716

FileClose(fp);

1717

for (lmax = 0, j = 0; j < n_seq; j++)

1718

if (lgseq[j] > lmax)

1719

lmax = lgseq[j];

1720

for (vnp = seqvnp, j = 0 && vnp != NULL; j < n_seq; j++, vnp = vnp->next)

1721

{

1722

tmp = (CharPtr) vnp->data.ptrvalue;

1723

tmp [lmax] = '\0';

1724

}

1725

if (lg_seq == 0 )

1726

lg_seq = lmax;

1727

else if (lmax < lg_seq)

1728

{

1729

if (lg_seq < LENGTHMAX ) {

1730

Message(MSG_OK, "Length in file %d != alignment length %d", (int) lg_seq, (int) lmax);

1731

/**** FREE DATA STRUCT ***********/

1732

return NULL;

1733

}

1734

lg_seq = lmax;

1735

}

1736

*offset_line = top_lines;

1737

return seqvnp;

1738

}

1739

1740

static SeqIdPtr ReadLocalName (CharPtr path, Int2 nbseq, Int2 leftmargin, Int2 offset_lines)

1741

{

1742

FILE *fp;

1743

SeqIdPtr sip1 = NULL,

1744

sipnew = NULL, siptmp;

1745

CharPtr str = NULL;

1746

Int2 j,

1747

i_seq = 0;

1748

1749

if ( (fp = FileOpen (path, "r")) != NULL) {

1750

j=0;

1751

str = FGetLine (fp);

1752

while (str && j<offset_lines) {

1753

MemFree (str);

1754

str = FGetLine (fp);

1755

j++;

1756

}

1757

while (str && i_seq < nbseq )

1758

{

1759

if ( StringLen (str) > 0 )

1760

{

1761

str [leftmargin] = '\0';

1762

for (j=leftmargin-1; j>0 && str[j] == ' '; j--)

1763

str[j] = '\0';

1764

sipnew = MakeSeqID (str);

1765

if (sip1 == NULL)

1766

sip1 = sipnew;

1767

else

1768

siptmp->next = sipnew;

1769

siptmp = sipnew;

1770

}

1771

MemFree (str);

1772

str = FGetLine (fp);

1773

++i_seq;

1774

}

1775

if (str)

1776

MemFree (str);

1777

FileClose(fp);

1778

}

1779

return sip1;

1780

}

1781

1782

static SeqEntryPtr ReadAlignmentFunc (CharPtr path, Uint1 mol_type, Uint1 format, Int2 n_seq, Boolean save_seqentry, Boolean save_sap, SeqIdPtr seqsip)

1783

{

1784

SeqEntryPtr sep = NULL;

1785

ValNodePtr seqvnp , vnp;

1786

SeqAnnotPtr sap;

1787

Int2 leftmargin,

1788

offset_lines,

1789

1790

CharPtr str;

1791

1792

seqvnp = ReadLocalAlign (path, format, n_seq, &leftmargin, &offset_lines);

1793

if (seqvnp == NULL)

1794

return NULL;

1795

for (k=0, vnp=seqvnp; vnp!=NULL; vnp=vnp->next) k++;

1796

if (n_seq == 0)

1797

n_seq = k;

1798

else

1799

if (k != n_seq) {

1800

ValNodeFree (seqvnp);

1801

return NULL;

1802

}

1803

if (seqsip== NULL)

1804

seqsip = ReadLocalName (path, n_seq, leftmargin, offset_lines);

1805

if (seqsip == NULL)

1806

{

1807

ValNodeFree (seqvnp);

1808

return NULL;

1809

}

1810

str=matching_seqid (seqsip);

1811

if (str)

1812

{

1813

ErrPostEx (SEV_ERROR, 0, 0, "The submission contains several sequences with the same name \"%s\"", str);

1814

MemFree (str);

1815

}

1816

else {

1817

if ( save_sap )

1818

sap = LocalAlignToSeqAnnotDimn (seqvnp, seqsip, NULL, n_seq, 0, NULL, FALSE);

1819

if ( save_seqentry )

1820

sep = strings_to_seqentry (seqvnp, mol_type, seqsip, sap);

1821

}

1822

ValNodeFree (seqvnp);

1823

SeqIdFree (seqsip);

1824

return sep;

1825

}

1826

1827

1828

/************************************************************

1829

*** ReadLocalAlignment

1830

*** called by sequin2.c

1831

*** calls ReadInterleaveAlign, ReadContiguouseAlign

1832

*** ReadInterleaveAlign

1833

*** reads formats: Phylip, NEXUS Interleave

1834

*** ReadContiguouseAlign

1835

*** reads formats: Fasta+gaps, NEXUS Contiguous, Macaw

1836

*** ReadAnyAlignment

1837

*** calls first ReadInterleaveAlign

1838

*** if NULL is returned, calls ReadContiguouseAlign

1839

***

1840

************************************************************/

1841

extern SeqEntryPtr ReadInterleaveAlign (CharPtr path, Uint1 mol_type)

1842

{

1843

FILE *fp;

1844

SeqEntryPtr sep=NULL;

1845

Char name [PATH_MAX];

1846

CharPtr tmp;

1847

CharPtr str = NULL;

1848

int val1;

1849

long val2;

1850

1851

if (path == NULL)

1852

{

1853

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

1854

return NULL;

1855

}

1856

path = name;

1857

}

1858

if ( (fp = FileOpen (path, "r")) != NULL) {

1859

str = get_first_notemptyline (fp);

1860

FileClose (fp);

1861

}

1862

if (str==NULL)

1863

return NULL;

1864

tmp = StringStr(str, "NEXUS");

1865

if (tmp == NULL)

1866

tmp = StringStr(str, "nexus");

1867

if (tmp)

1868

{

1869

if (ISA_aa(mol_type))

1870

sep = ReadLocalAlignment (SALSAA_NEXUS, path);

1871

else

1872

sep = ReadLocalAlignment (SALSA_NEXUS, path);

1873

if (str)

1874

MemFree (str);

1875

return sep;

1876

}

1877

if (sscanf (str, "%d %ld", &val1, &val2) == 2) {

1878

if (val1 > 0 && val2 > -1)

1879

{

1880

if (ISA_aa(mol_type))

1881

sep = ReadLocalAlignment (SALSAA_PHYLIP, path);

1882

else

1883

sep = ReadLocalAlignment (SALSA_PHYLIP, path);

1884

}

1885

if (str)

1886

MemFree (str);

1887

return sep;

1888

}

1889

ErrPostEx (SEV_ERROR, 0, 0, "We do not support this format yet");

1890

return NULL;

1891

}

1892

1893

extern SeqEntryPtr ReadContiguouseAlign (CharPtr path, Uint1 mol_type)

1894

{

1895

FILE *fp;

1896

SeqEntryPtr sep=NULL;

1897

Char name [PATH_MAX];

1898

CharPtr tmp;

1899

CharPtr str = NULL;

1900

1901

if (path == NULL)

1902

{

1903

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

1904

return NULL;

1905

}

1906

path = name;

1907

}

1908

if ( (fp = FileOpen (path, "r")) != NULL) {

1909

str = get_first_notemptyline (fp);

1910

FileClose (fp);

1911

}

1912

if (str==NULL)

1913

return NULL;

1914

1915

if (str[0] == '>' || str[0] == '[')

1916

{

1917

if (ISA_aa(mol_type))

1918

sep = ReadLocalAlignment (SALSAA_FASTGAP, path);

1919

else

1920

sep = ReadLocalAlignment (SALSA_FASTGAP, path);

1921

if (str)

1922

MemFree (str);

1923

return sep;

1924

}

1925

tmp = StringStr(str, "NEXUS");

1926

if (tmp == NULL)

1927

tmp = StringStr(str, "nexus");

1928

if (tmp)

1929

{

1930

if (!ISA_aa(mol_type))

1931

sep = ReadLocalAlignment (SALSA_PAUP, path);

1932

if (str)

1933

MemFree (str);

1934

return sep;

1935

}

1936

tmp = StringStr(str, "MACAWDATAFILE");

1937

if (tmp == NULL)

1938

tmp = StringStr(str, "MacawDataFile");

1939

if (tmp)

1940

{

1941

if (!ISA_aa(mol_type))

1942

sep = ReadLocalAlignment (SALSA_MACAW, path);

1943

if (str)

1944

MemFree (str);

1945

return sep;

1946

}

1947

ErrPostEx (SEV_ERROR, 0, 0, "We do not support this format yet");

1948

return NULL;

1949

}

1950

1951

extern SeqEntryPtr ReadAnyAlignment (Boolean is_prot, CharPtr path)

1952

{

1953

SeqEntryPtr sep = NULL;

1954

Uint1 mol_type=Seq_mol_na;

1955

Char name [PATH_MAX];

1956

ErrSev errlev;

1957

1958

1959

if (is_prot)

1960

mol_type = Seq_mol_aa;

1961

if (path == NULL)

1962

{

1963

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

1964

return NULL;

1965

}

1966

path = name;

1967

}

1968

errlev = ErrSetMessageLevel (SEV_FATAL);

1969

sep = AsnReadForSalsa (path);

1970

if (sep==NULL) {

1971

sep = ReadInterleaveAlign (path, mol_type);

1972

}

1973

if (sep==NULL) {

1974

sep = ReadContiguouseAlign (path, mol_type);

1975

}

1976

ErrSetMessageLevel (errlev);

1977

return sep;

1978

}

1979

1980

1981

extern SeqEntryPtr ReadLocalAlignment (Uint1 format, CharPtr path)

1982

{

1983

SeqEntryPtr sep = NULL;

1984

Char name [PATH_MAX];

1985

Char tmpfile [PATH_MAX];

1986

1987

if (path == NULL)

1988

{

1989

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

1990

return NULL;

1991

}

1992

path = name;

1993

}

1994

switch (format)

1995

{

1996

case SALSA_ND:

1997

sep = ReadAnyAlignment (FALSE, path);

1998

break;

1999

2000

case SALSA_INTERLEAVE:

2001

sep = ReadInterleaveAlign (path, Seq_mol_na);

2002

break;

2003

case SALSAA_INTERLEAVE :

2004

sep = ReadInterleaveAlign (path, Seq_mol_aa);

2005

break;

2006

case SALSA_CONTIGUOUS:

2007

sep = ReadContiguouseAlign (path, Seq_mol_na);

2008

break;

2009

case SALSAA_CONTIGUOUS:

2010

sep = ReadContiguouseAlign (path, Seq_mol_aa);

2011

break;

2012

2013

case SALSA_FASTA:

2014

sep = FastaReadAdvanced (path, Seq_mol_na, NULL, NULL, NULL, NULL);

2015

break;

2016

case SALSAA_FASTA:

2017

sep = FastaReadAdvanced (path, Seq_mol_aa, NULL, NULL, NULL, NULL);

2018

break;

2019

2020

case SALSA_FASTGAP:

2021

sep = GapFastaRead (path, Seq_mol_na);

2022

break;

2023

case SALSAA_FASTGAP:

2024

sep = GapFastaRead (path, Seq_mol_aa);

2025

break;

2026

case SALSA_PHYLIP:

2027

case SALSA_NEXUS:

2028

sep = ReadAlignmentFunc (path, Seq_mol_na, format, 0, TRUE, TRUE, NULL);

2029

break;

2030

2031

case SALSAA_PHYLIP:

2032

case SALSAA_NEXUS:

2033

case SALSAA_GCG:

2034

sep = ReadAlignmentFunc (path, Seq_mol_aa, format, 0, TRUE, TRUE, NULL);

2035

break;

2036

case SALSA_PAUP:

2037

TmpNam (tmpfile);

2038

if (ConvertPaupToFastaGap (path, tmpfile) )

2039

{

2040

sep = GapFastaRead (tmpfile, Seq_mol_na);

2041

FileRemove (tmpfile);

2042

}

2043

break;

2044

case SALSA_MACAW :

2045

sep = MacawRead (path, Seq_mol_na, NULL, TRUE, TRUE);

2046

break;

2047

2048

default:

2049

ErrPostEx (SEV_ERROR, 0, 0, "We do not support this format yet");

2050

break;

2051

}

2052

return sep;

2053

}

2054

2055

2056

/***********************************************************

2057

***

2058

*** Import functions:

2059

*** from any file (ASN.1, FASTA, gi/acc#),

2060

*** calls ReadAsnFastaOrFlatFile

2061

*** Download from Entrez

2062

*** copy of FetchFromNet from sequin2.c (JK)

2063

***

2064

************************************************************/

2065

2066

extern SeqAlignPtr ImportFromFile (EditAlignDataPtr adp)

2067

{

2068

SeqAlignPtr salp = NULL,

2069

salptmp,

2070

salp_original=NULL;

2071

SeqAnnotPtr sap = NULL;

2072

SeqEntryPtr sep = NULL;

2073

ValNodePtr importslp = NULL,

2074

sqloc = NULL;

2075

SeqLocPtr slp;

2076

Boolean new_seqalign=FALSE,

2077

ok=FALSE,

2078

replace_salp=FALSE;

2079

MsgAnswer ans;

2080

2081

if (adp==NULL)

2082

return NULL;

2083

2084

importslp = CCReadAnythingLoop (NULL, adp->seq_info);

2085

if (importslp != NULL)

2086

{

2087

if (adp->sap_original != NULL)

2088

{

2089

salp_original = (SeqAlignPtr)(adp->sap_original->data);

2090

if (salp_original)

2091

ok=SeqAlignSeqLocComp (salp_original, importslp);

2092

if (!ok)

2093

{

2094

if (salp_original->dim==2 || is_dim2seqalign (salp_original))

2095

salp_original=salp_original;

2096

else if (salp_original->dim == 1)

2097

{

2098

replace_salp = TRUE;

2099

salp_original=NULL;

2100

}

2101

else {

2102

ans = Message (MSG_OKC, "You have a multiple alignment.\n Importing a sequence will convert it into a multiple pairwise alignment.\n Do you want to continue ?");

2103

if (ans != ANS_CANCEL) {

2104

salptmp = multseqalign_to_pairseqalign (salp_original);

2105

if (salptmp) {

2106

SeqAlignListFree (salp_original);

2107

adp->sap_original->data = (Pointer) salptmp;

2108

salp_original = salptmp;

2109

}

2110

else

2111

salp_original=NULL;

2112

}

2113

else

2114

salp_original=NULL;

2115

}

2116

}

2117

if (salp_original)

2118

{

2119

slp = (SeqLocPtr) adp->master.region;

2120

if (slp!=NULL)

2121

{

2122

ValNodeAddPointer (&sqloc, 0, (Pointer)slp);

2123

sqloc->next = importslp;

2124

salp = SeqLocListToSeqAlign (sqloc, (Int2)adp->align_format, NULL);

2125

if (salp!=NULL)

2126

{

2127

if (salp_original != NULL) {

2128

salp = SeqAlignLink (salp_original, salp);

2129

new_seqalign = TRUE;

2130

}

2131

}

2132

else {

2133

if (adp->align_format==PRG_BLAST || adp->align_format==PRGALIGNDEFAULT)

2134

Message (MSG_OK, "Blast detected no sequence similarity and could not construct an alignment");

2135

else

2136

Message (MSG_OK, "No significant similarity detected. No alignment produced");

2137

}

2138

}

2139

if (!new_seqalign && !replace_salp)

2140

salp = SeqAlignSetFree (salp);

2141

}

2142

}

2143

else

2144

Message(MSG_OK, "Can not import a sequence already in the editor");

2145

}

2146

return salp;

2147

}

2148

2149

/*------------------------------------------------------------*/

2150

typedef struct salfilesfetchform {

2151

FORM_MESSAGE_BLOCK

2152

GrouP accntype;

2153

TexT accession;

2154

ButtoN accept;

2155

EditAlignDataPtr adp;

2156

WindoW editor_window;

2157

} FetchForm, PNTR FetchFormPtr;

2158

2159

static void FetchFormMessage (ForM f, Int2 mssg)

2160

{

2161

FetchFormPtr ffp;

2162

2163

ffp = (FetchFormPtr) GetObjectExtra (f);

2164

if (ffp != NULL) {

2165

switch (mssg) {

2166

case VIB_MSG_CUT :

2167

StdCutTextProc (NULL);

2168

break;

2169

case VIB_MSG_COPY :

2170

StdCopyTextProc (NULL);

2171

break;

2172

case VIB_MSG_PASTE :

2173

StdPasteTextProc (NULL);

2174

break;

2175

case VIB_MSG_DELETE :

2176

StdDeleteTextProc (NULL);

2177

break;

2178

default :

2179

if (ffp->appmessage != NULL) {

2180

ffp->appmessage (f, mssg);

2181

}

2182

break;

2183

}

2184

}

2185

}

2186

2187

static void FetchTextProc (TexT t)

2188

{

2189

FetchFormPtr ffp;

2190

2191

ffp = (FetchFormPtr) GetObjectExtra (t);

2192

if (ffp == NULL) return;

2193

if (TextHasNoText (t)) {

2194

SafeDisable (ffp->accept);

2195

} else {

2196

SafeEnable (ffp->accept);

2197

}

2198

}

2199

2200

static SeqAlignPtr align_this (SeqEntryPtr sep, SeqLocPtr master, SeqAnnotPtr sap, WindoW editor_window, EditAlignDataPtr adp)

2201

{

2202

SeqAlignPtr salp = NULL,

2203

salptmp,

2204

salp_original = NULL;

2205

ValNodePtr vnp=NULL,

2206

vnp2=NULL;

2207

Int2 n;

2208

Boolean ok = FALSE,

2209

new_seqalign = FALSE,

2210

replace_salp = FALSE;

2211

MsgAnswer ans;

2212

2213

if (sep==NULL)

2214

return NULL;

2215

if (!IS_Bioseq(sep))

2216

return NULL;

2217

2218

vnp = SeqEntryToSeqLoc (sep, &n, adp->mol_type);

2219

if (vnp)

2220

{

2221

if (sap)

2222

{

2223

salp_original = (SeqAlignPtr)(sap->data);

2224

if (salp_original->dim==2 || is_dim2seqalign (salp_original))

2225

salp_original=salp_original;

2226

else if (salp_original->dim == 1)

2227

{

2228

replace_salp = TRUE;

2229

salp_original=NULL;

2230

}

2231

else {

2232

ans = Message (MSG_OKC, "You have a multiple alignment.\n Importing a sequence will convert it into a multiple pairwise alignment.\n Do you want to continue ?");

2233

if (ans != ANS_CANCEL) {

2234

salptmp = multseqalign_to_pairseqalign (salp_original);

2235

if (salptmp)

2236

{

2237

adp->sap_original->data = (Pointer) salptmp;

2238

salp_original = salptmp;

2239

}

2240

else

2241

salp_original=NULL;

2242

}

2243

else

2244

salp_original=NULL;

2245

}

2246

}

2247

if (salp_original)

2248

ok=SeqAlignSeqLocComp (salp_original, vnp);

2249

if (!ok)

2250

{

2251

if (master!=NULL)

2252

{

2253

ValNodeAddPointer(&vnp2, 0, (Pointer)master);

2254

vnp2->next=vnp;

2255

vnp=vnp2;

2256

}

2257

salp = SeqLocListToSeqAlign (vnp, adp->align_format, NULL);

2258

if (salp!=NULL)

2259

{

2260

if (salp_original)

2261

{

2262

salp = SeqAlignLink (salp_original, salp);

2263

new_seqalign = TRUE;

2264

}

2265

}

2266

else {

2267

if (adp->align_format==PRG_BLAST || adp->align_format==PRGALIGNDEFAULT)

2268

Message (MSG_OK, "Blast detected no sequence similarity and could not construct an alignment");

2269

else

2270

Message (MSG_OK, "No significant similarity detected. No alignment produced");

2271

}

2272

if (new_seqalign || replace_salp) {

2273

repopulate_panel (editor_window, adp, salp);

2274

}

2275

else

2276

salp = SeqAlignSetFree (salp);

2277

}

2278

else

2279

Message(MSG_OK, "Can not import a sequence already in the editor");

2280

}

2281

return salp;

2282

}

2283

2284

static SeqEntryPtr SeqEntryNewForBioseq (BioseqPtr bsp)

2285

{

2286

SeqEntryPtr new_sep;

2287

BioseqPtr new_bsp;

2288

SeqLocPtr slp;

2289

SeqIdPtr new_sip;

2290

2291

slp=SeqLocIntNew(0, bsp->length-1, Seq_strand_plus, bsp->id);

2292

new_sip = MakeNewProteinSeqId (slp, NULL);

2293

new_bsp=BioseqCopy(new_sip, bsp->id, 0, bsp->length-1, Seq_strand_plus, TRUE);

2294

if (new_bsp) {

2295

new_sep=SeqEntryNew();

2296

new_sep->choice = 1;

2297

new_sep->data.ptrvalue=(Pointer)new_bsp;

2298

SeqMgrSeqEntry (SM_BIOSEQ, (Pointer) new_bsp, new_sep);

2299

}

2300

ValNodeFree(slp);

2301

return new_sep;

2302

}

2303

2304

static void CCDownloadProc (ButtoN b)

2305

2306

{

2307

CharPtr accn;

2308

BioseqPtr bsp;

2309

Uint2 entityID;

2310

FetchFormPtr ffp;

2311

SeqEntryPtr sep;

2312

Char str [32];

2313

Int4 uid;

2314

ForM w;

2315

Boolean is_na,

2316

is_newbsp=FALSE;

2317

SeqEditViewProcsPtr svpp;

2318

2319

ffp = (FetchFormPtr) GetObjectExtra (b);

2320

if (ffp == NULL) return;

2321

svpp = (SeqEditViewProcsPtr) GetAppProperty ("SeqEditDisplayForm");

2322

if (svpp == NULL)

2323

return;

2324

if (svpp->download == NULL)

2325

return;

2326

w = ffp->form;

2327

Hide (w);

2328

Update ();

2329

GetTitle (ffp->accession, str, sizeof (str));

2330

if (StringHasNoText (str)) {

2331

Message (MSG_OK, "Please enter an accession number or gi");

2332

Show (w);

2333

Select (w);

2334

Select (ffp->accession);

2335

return;

2336

}

2337

is_na = (Boolean) (ISA_na(ffp->adp->mol_type));

2338

WatchCursor ();

2339

sep = NULL;

2340

uid = 0;

2341

accn = NULL;

2342

if (GetValue (ffp->accntype) == 1) {

2343

accn = &(str [0]);

2344

}

2345

else {

2346

if (! StrToLong (str, &uid)) {

2347

uid = 0;

2348

}

2349

}

2350

sep = svpp->download ("Salsa", accn, uid, is_na, &is_newbsp);

2351

if (sep == NULL) {

2352

Message (MSG_OK, "Unable to find this record in the database.");

2353

}

2354

else {

2355

Remove (w);

2356

if (!is_newbsp)

2357

{

2358

if (IS_Bioseq(sep)) {

2359

sep = SeqEntryNewForBioseq ((BioseqPtr)sep->data.ptrvalue);

2360

} else {

2361

SeqEntryFree (sep);

2362

sep=NULL;

2363

}

2364

}

2365

if (sep!=NULL) {

2366

align_this(sep, (SeqLocPtr)ffp->adp->master.region,

2367

ffp->adp->sap_original, ffp->editor_window, ffp->adp);

2368

}

2369

}

2370

ArrowCursor ();

2371

return;

2372

}

2373

2374

static void CCCommonFetchFromNet (BtnActnProc actn, BtnActnProc cancel, EditAlignDataPtr adp, WindoW editor_window)

2375

2376

{

2377

GrouP c;

2378

FetchFormPtr ffp;

2379

GrouP g;

2380

WindoW w;

2381

2382

Update ();

2383

w = NULL;

2384

ffp = MemNew (sizeof (FetchForm));

2385

if (ffp != NULL) {

2386

w = FixedWindow (-50, -33, -10, -10, "Download From Entrez", NULL);

2387

SetObjectExtra (w, ffp, StdCleanupFormProc);

2388

ffp->form = (ForM) w;

2389

ffp->formmessage = FetchFormMessage;

2390

ffp->adp= adp;

2391

ffp->editor_window = editor_window;

2392

SetGroupSpacing (w, 10, 10);

2393

2394

g = HiddenGroup (w, -3, 0, NULL);

2395

StaticPrompt (g, "Type", 0, stdLineHeight, programFont, 'l');

2396

ffp->accntype = HiddenGroup (g, 4, 0, NULL);

2397

RadioButton (ffp->accntype, "Accession");

2398

RadioButton (ffp->accntype, "GI");

2399

SetValue (ffp->accntype, 1);

2400

ffp->accession = DialogText (g, "", 6, FetchTextProc);

2401

SetObjectExtra (ffp->accession, ffp, NULL);

2402

2403

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

2404

SetGroupSpacing (c, 10, 2);

2405

ffp->accept = DefaultButton (c, "Retrieve", actn);

2406

SetObjectExtra (ffp->accept, ffp, NULL);

2407

Disable (ffp->accept);

2408

PushButton (c, "Cancel", cancel);

2409

2410

AlignObjects (ALIGN_CENTER, (HANDLE) g, (HANDLE) c, NULL);

2411

RealizeWindow (w);

2412

Show (w);

2413

Select (w);

2414

Update ();

2415

}

2416

}

2417

2418

extern void CCFetchFromNet (EditAlignDataPtr adp, WindoW editor_window)

2419

{

2420

CCCommonFetchFromNet (CCDownloadProc, StdCancelButtonProc, adp, editor_window);

2421

}

2422

2423

2424

/************************************************************

2425

*** EditBioseqToFasta called by salparam.c

2426

SHOULD BE SEQ-ENTRY /Bioseq, Bioseqet

2427

2428

if ( (fout = FileOpen ("ffile", "w")) != NULL) {

2429

sep = bssp->seq_set;

2430

while (sep != NULL)

2431

{

2432

count++;

2433

if (count == 1 && !firstout) {}

2434

else {

2435

bsp = (BioseqPtr) sep->data.ptrvalue;

2436

EditBioseqToFasta (bsp, fout, -1, -1);

2437

}

2438

sep = sep->next;

2439

}

2440

FileClose (fout);

2441

return TRUE;

2442

}

2443

************************************************************/

2444

extern void EditBioseqToFasta (BioseqPtr bsp, FILE *fout, Int4 from, Int4 to)

2445

{

2446

SeqLocPtr slp;

2447

SeqPortPtr spp;

2448

Char buffer[128];

2449

Char str [128];

2450

Int4 txt_out;

2451

Int4 Width_Page = 60;

2452

Int4 j;

2453

2454

if (bsp == NULL)

2455

return;

2456

if (fout == NULL)

2457

return;

2458

SeqIdWrite (SeqIdFindBest(bsp->id, 0), str, PRINTID_FASTA_LONG, 120);

2459

if (from < 0)

2460

from = 0;

2461

if (to < 0)

2462

to = bsp->length-1;

2463

fprintf (fout, ">%s (%ld - %ld)\n", str, (long)(from+1), (long)(to+1));

2464

slp = SeqLocIntNew (from, to, Seq_strand_plus, SeqIdFindBest(bsp->id, 0));

2465

if ( bsp->mol == Seq_mol_aa )

2466

spp = SeqPortNewByLoc (slp, Seq_code_ncbieaa);

2467

else

2468

spp = SeqPortNewByLoc (slp, Seq_code_iupacna);

2469

j = 0;

2470

while ( j < SeqLocStop (slp) - SeqLocStart (slp) +1)

2471

{

2472

txt_out = ReadBufferFromSep (spp, buffer, j, j +Width_Page, 0);

2473

if (txt_out == 0) break;

2474

j += txt_out;

2475

fprintf(fout, "%s\n", buffer);

2476

}

2477

SeqPortFree (spp);

2478

return;

2479

}

2480

2481

/************************************************************/

2482

extern Int2 seqannot_write (SeqAnnotPtr sap, CharPtr path)

2483

{

2484

Char name[PATH_MAX];

2485

AsnIoPtr aip;

2486

AsnTypePtr atp;

2487

AsnModulePtr amp;

2488

SeqAnnotPtr saptmp;

2489

SeqAlignPtr salp;

2490

2491

if ( sap == NULL ) {

2492

return 0;

2493

}

2494

if ( ( salp = (SeqAlignPtr) sap->data ) == NULL ) {

2495

return 0;

2496

}

2497

if ( salp->segtype == COMPSEG ) {

2498

saptmp = SeqAnnotBoolSegToDenseSeg (sap);

2499

}

2500

else saptmp = sap;

2501

if (path == NULL) {

2502

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

2503

return 0;

2504

}

2505

path = name;

2506

}

2507

amp = AsnAllModPtr ();

2508

atp = AsnTypeFind (amp,"Seq-annot");

2509

if ((aip = AsnIoOpen (path, "w")) == NULL) {

2510

return 0;

2511

}

2512

while ( sap != NULL ) {

2513

if ( ! SeqAnnotAsnWrite ( sap, aip, atp ) ) {

2514

break;

2515

}

2516

sap = sap->next;

2517

}

2518

AsnIoReset(aip);

2519

aip = AsnIoClose (aip);

2520

if ( salp->segtype == COMPSEG ) CompSeqAnnotFree (saptmp);

2521

return 1;

2522

}

2523

2524

/************************************************************/

2525

extern void seqalign_write (SeqAlignPtr salp, CharPtr path)

2526

{

2527

SeqAnnotPtr sap;

2528

2529

if (salp!=NULL) {

2530

sap = SeqAnnotNew ();

2531

if (sap != NULL) {

2532

sap->type = 2;

2533

sap->data = (Pointer) salp;

2534

seqannot_write (sap, path);

2535

sap->data = NULL;

2536

sap = SeqAnnotFree (sap);

2537

}

2538

}

2539

}

2540

2541

/************************************************************

2542

*************************************************************

2543

*************************************************************

2544

*************************************************************

2545

*** FEATURES

2546

*********************************************************

2547

*************************************************************

2548

*************************************************************

2549

*************************************************************

2550

*************************************************************

2551

**********************************************************/

2552

static Boolean seqentry_write (SeqEntryPtr sep, CharPtr path)

2553

{

2554

Char name[PATH_MAX];

2555

AsnIoPtr aip;

2556

AsnTypePtr atp;

2557

AsnModulePtr amp;

2558

2559

if ( sep == NULL ) {

2560

return 0;

2561

}

2562

if (path == NULL )

2563

{

2564

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

2565

return 0;

2566

}

2567

path = name;

2568

}

2569

amp = AsnAllModPtr ();

2570

atp = AsnTypeFind (amp,"SeqEntry");

2571

if ((aip = AsnIoOpen (path,"w")) == NULL) {

2572

return 0;

2573

}

2574

if ( ! SeqEntryAsnWrite ( sep, aip, atp ) ) {

2575

}

2576

aip = AsnIoClose (aip);

2577

return 1;

2578

}

2579

2580

static void get_client_rect (PaneL p, RectPtr prc)

2581

{

2582

ObjectRect (p, prc);

2583

InsetRect (prc, HRZ_BORDER_WIDTH, VER_BORDER_WIDTH);

2584

}

2585

2586

/***************************************************************

2587

*** switch_featOrder

2588

***

2589

*****************************************************************/

2590

static void switch_featOrder (EditAlignDataPtr adp, Uint1 choice)

2591

{

2592

Int2 oldstyle;

2593

Int2 j;

2594

Int4 groupNum;

2595

2596

if (choice > 0) {

2597

oldstyle = GetMuskCurrentSt ();

2598

SetMuskCurrentSt (GetMuskStyleName (adp->styleNum));

2599

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

2600

{

2601

adp->featOrder[j] = (Uint1)GetMuskCParam(j, MSM_FORDER, MSM_NUM);

2602

groupNum = (Uint1)GetMuskCParam(j, MSM_FGROUP, MSM_NUM);

2603

adp->groupOrder[j] = (Uint1)GetMuskCParam(MSM_GROUPS, (Int2)groupNum, MSM_NUM);

2604

}

2605

SetMuskCurrentSt (GetMuskStyleName (oldstyle));

2606

}

2607

else

2608

for(j=0; j<FEATDEF_ANY; ++j) adp->featOrder[j] = choice;

2609

}

2610

2611

2612

/*********************************************

2613

*** sesp_to_pept

2614

***

2615

***

2616

*********************************************/

2617

typedef struct ccid {

2618

SeqIdPtr sip;

2619

SeqEntryPtr sep;

2620

BioseqPtr bsp;

2621

} CcId, PNTR CcIdPtr;

2622

2623

static void FindSeqEntryForSeqIdCallback (SeqEntryPtr sep, Pointer mydata,

2624

Int4 index, Int2 indent)

2625

{

2626

BioseqPtr bsp;

2627

SeqIdPtr sip;

2628

CcIdPtr cip;

2629

2630

if (sep != NULL && sep->data.ptrvalue && mydata != NULL) {

2631

cip = (CcIdPtr)mydata;

2632

if (IS_Bioseq(sep)) {

2633

bsp = (BioseqPtr) sep->data.ptrvalue;

2634

if (bsp!=NULL && ISA_na (bsp->mol)) {

2635

sip = SeqIdFindBest(bsp->id, 0);

2636

if (SeqIdForSameBioseq(cip->sip, sip))

2637

cip->sep = sep;

2638

cip->bsp = bsp;

2639

}

2640

}

2641

}

2642

}

2643

2644

static Int2 CC_SeqEntryToGeneticCode (Uint2 entityID, SeqIdPtr sip)

2645

{

2646

SeqEntryPtr sep_head,

2647

sep;

2648

CcId ci;

2649

Int2 genCode = 0;

2650

2651

sep_head = GetTopSeqEntryForEntityID (entityID);

2652

ci.sip = SeqIdDup (sip);

2653

ci.sep = NULL;

2654

ci.bsp = NULL;

2655

SeqEntryExplore(sep_head,(Pointer)&ci, FindSeqEntryForSeqIdCallback);

2656

sep = ci.sep;

2657

SeqIdFree (ci.sip);

2658

if (sep!=NULL)

2659

genCode = SeqEntryToGeneticCode (sep, NULL, NULL, 0);

2660

return genCode;

2661

}

2662

2663

2664

extern Boolean sesp_to_pept (SelEdStructPtr cds, SeqAlignPtr salp, ValNodePtr sqlocs, Boolean partial)

2665

{

2666

SelEdStructPtr cdsp;

2667

SelEdStructPtr cds1;

2668

SeqLocPtr slp;

2669

SeqIntPtr sit;

2670

ValNodePtr pept;

2671

ByteStorePtr bsp;

2672

CharPtr pep = NULL;

2673

CharPtr pepPtr = NULL;

2674

CharPtr str = NULL,

2675

strPtr = NULL;

2676

CharPtr buffer = NULL,

2677

bufferPtr = NULL;

2678

Int4 k,

2679

strlens, slplens;

2680

Int4 sumlens;

2681

Int2 genCode;

2682

Int2 cb;

2683

Uint1 codonbase;

2684

Uint1 codonstart;

2685

Uint1 strand;

2686

2687

if ( cds == NULL || salp == NULL )

2688

return FALSE;

2689

if (cds->regiontype == 0 || cds->region == NULL)

2690

return FALSE;

2691

cds1 = cds;

2692

while (cds1->prev != NULL) {

2693

cds1 = cds1->prev;

2694

}

2695

slp = sesp_to_slp (cds1, salp, sqlocs, partial);

2696

slplens = SeqLocLen (slp);

2697

if ( slplens < 3 ) {

2698

SeqLocFree (slp);

2699

return FALSE;

2700

}

2701

if (SeqLocStart(slp) > 0)

2702

codonstart = 1;

2703

else

2704

codonstart = cds1->codonstart;

2705

strand = SeqLocStrand (slp);

2706

2707

genCode = CC_SeqEntryToGeneticCode (cds1->entityID, SeqLocId(slp));

2708

if (genCode == 0)

2709

genCode = Seq_code_ncbieaa;

2710

2711

codonbase = 0;

2712

sit = (SeqIntPtr) slp->data.ptrvalue;

2713

if (strand == Seq_strand_minus && codonstart > 1) {

2714

cb = (Int2)(slplens % (Int4) 3);

2715

if (cb == 1) {

2716

sit->to --;

2717

}

2718

}

2719

else if (strand == Seq_strand_minus) {

2720

cb = (Int2)(slplens % (Int4) 3);

2721

if (cb == 1 && sit->from >0) {

2722

sit->from --;

2723

} else if (cb == 2) {

2724

sit->from ++;

2725

}

2726

if (cb == 0) codonbase = 0;

2727

else if (cb == 1) codonbase = 1;

2728

else if (cb == 2) codonbase = 2;

2729

}

2730

slplens = SeqLocLen (slp);

2731

bsp = cds_to_pept (slp, codonstart, genCode, TRUE);

2732

str = (CharPtr) BSMerge (bsp, NULL);

2733

BSFree (bsp);

2734

pep = MemNew ((size_t) ((slplens + 5) *sizeof(Char)));

2735

pep = emptystring (pep, (Int4)(slplens + 5));

2736

pep [slplens + 3] = '\0';

2737

pepPtr = pep;

2738

*pepPtr = ' ';

2739

pepPtr += codonbase +1;

2740

strlens = 3*StringLen(str);

2741

if (slplens < strlens) {

2742

strlens=(Int4)(slplens/(Int4)3);

2743

str [strlens] ='\0';

2744

}

2745

if (strand == Seq_strand_minus)

2746

reverse_string (str);

2747

strlens = StringLen(str);

2748

strPtr = str;

2749

for (k = 0; k < strlens; k++, pepPtr += 3, strPtr++) {

2750

*pepPtr = *strPtr;

2751

}

2752

MemFree (str);

2753

2754

strlens = SeqLocLen (slp) + 5;

2755

buffer = MemNew ((size_t) (strlens *sizeof(Char)));

2756

buffer = emptystring (buffer, strlens);

2757

buffer [strlens -1] = '\0';

2758

bufferPtr = buffer;

2759

*bufferPtr = ' ';

2760

sip = SeqLocId (slp);

2761

for (cdsp= cds1; cdsp != NULL; cdsp = cdsp->next)

2762

{

2763

slp = (SeqLocPtr) cdsp->region;

2764

buffer = ReadBufferFromSap (pep, buffer, salp, sip, SeqLocStart(slp), SeqLocStop(slp));

2765

}

2766

MemFree (pep);

2767

2768

buffer = pep;

2769

SeqLocFree (slp);

2770

if (cds1->data != NULL) {

2771

pept = cds1->data;

2772

cds1->data = NULL;

2773

pept->data.ptrvalue = MemFree (pept->data.ptrvalue);

2774

pept = ValNodeFree (pept);

2775

}

2776

sumlens = 0;

2777

for (cdsp= cds1; cdsp != NULL; cdsp = cdsp->next)

2778

{

2779

pept = ValNodeNew (NULL);

2780

pept->choice = 0;

2781

pept->data.ptrvalue = (Pointer) buffer;

2782

cdsp->data = pept;

2783

cdsp->offset = sumlens;

2784

sumlens += SeqLocLen ((SeqLocPtr) cdsp->region);

2785

pept = NULL;

2786

}

2787

return TRUE;

2788

}

2789

2790

2791

/*******************************************************************

2792

*** TranslateProc, TranslateButton

2793

***

2794

*** CdRgnToProtProc

2795

***

2796

********************************************************************/

2797

extern void CdRgnToProtProc (PaneL pnl, EditAlignDataPtr adp)

2798

{

2799

WindoW temport;

2800

SelStructPtr ssp;

2801

SelEdStructPtr cds;

2802

ValNodePtr feathead = NULL,

2803

vnp = NULL;

2804

Uint2 itemsubtype;

2805

Boolean seq_select = FALSE;

2806

float hratio;

2807

2808

hratio = (float)adp->hoffset / (float)adp->length;

2809

ssp = ObjMgrGetSelected();

2810

for (; ssp != NULL; ssp = ssp->next)

2811

{

2812

if ( checkssp_for_editor (ssp) && ssp->itemtype == OBJ_VIRT) {

2813

feathead = adp->feat;

2814

itemsubtype = FEATDEF_CDS;

2815

}

2816

else if ( checkssp_for_editor (ssp) && ssp->itemtype == OBJ_SEQFEAT) {

2817

feathead = adp->seqfeat;

2818

itemsubtype = SEQFEAT_CDREGION;

2819

}

2820

else feathead = NULL;

2821

if (feathead != NULL)

2822

{

2823

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

2824

{

2825

if (vnp->choice == itemsubtype) {

2826

cds = (SelEdStructPtr) vnp->data.ptrvalue;

2827

if (cds->entityID == ssp->entityID && cds->itemID == ssp->itemID)

2828

{

2829

if (sesp_to_pept(cds, (SeqAlignPtr) adp->sap_align->data, adp->sqloc_list, TRUE))

2830

seq_select = TRUE;

2831

break;

2832

}

2833

}

2834

}

2835

}

2836

}

2837

if (!seq_select) return;

2838

data_collect_arrange (adp, TRUE);

2839

SeqEdSetCorrectBarMax (pnl, adp, hratio);

2840

temport = SavePort(ParentWindow(pnl));

2841

Select (pnl);

2842

inval_panel (pnl, -1, -1);

2843

RestorePort (temport);

2844

return;

2845

}

2846

2847

/*******************************************************************

2848

***

2849

*** UntranslateFunc

2850

***

2851

********************************************************************/

2852

extern void UntranslateFunc (PaneL pnl, EditAlignDataPtr adp)

2853

{

2854

WindoW temport;

2855

SelStructPtr ssp;

2856

SelEdStructPtr cds;

2857

ValNodePtr pept;

2858

ValNodePtr feathead = NULL, vnp = NULL;

2859

Uint2 itemsubtype;

2860

Boolean seq_select = FALSE;

2861

float hratio;

2862

2863

hratio = (float)adp->hoffset / (float)adp->length;

2864

ssp = ObjMgrGetSelected();

2865

for (; ssp != NULL; ssp = ssp->next)

2866

{

2867

if ( checkssp_for_editor (ssp) && ssp->itemtype == OBJ_VIRT) {

2868

feathead = adp->feat;

2869

itemsubtype = FEATDEF_CDS;

2870

}

2871

else if ( checkssp_for_editor (ssp) && ssp->itemtype == OBJ_SEQFEAT) {

2872

feathead = adp->seqfeat;

2873

itemsubtype = SEQFEAT_CDREGION;

2874

}

2875

else feathead = NULL;

2876

if (feathead != NULL) {

2877

for (vnp = feathead; vnp != NULL; vnp = vnp->next) {

2878

if (vnp->choice == itemsubtype)

2879

{

2880

cds = (SelEdStructPtr) vnp->data.ptrvalue;

2881

if (cds->entityID == ssp->entityID && cds->itemID == ssp->itemID)

2882

{

2883

if (cds->data != NULL) {

2884

pept = cds->data;

2885

cds->data = NULL;

2886

pept->data.ptrvalue = MemFree (pept->data.ptrvalue);

2887

ValNodeFree (pept);

2888

for (; cds != NULL; cds = cds->next) {

2889

cds->data = NULL;

2890

}

2891

seq_select = TRUE;

2892

}

2893

break;

2894

}

2895

}

2896

}

2897

}

2898

}

2899

if (!seq_select) return;

2900

data_collect_arrange (adp, TRUE);

2901

SeqEdSetCorrectBarMax (pnl, adp, hratio);

2902

temport = SavePort(ParentWindow(pnl));

2903

Select (pnl);

2904

inval_panel (pnl, -1, -1);

2905

RestorePort (temport);

2906

return;

2907

}

2908

2909

2910

2911

extern Boolean ShowFeatureFunc (EditAlignDataPtr adp)

2912

{

2913

AlignNodePtr anp;

2914

ValNodePtr vnp;

2915

SeqLocPtr slp;

2916

Boolean seq_select = FALSE;

2917

2918

switch_featOrder (adp, 1);

2919

adp->seqfeat = SeqfeatlistFree (adp->seqfeat);

2920

for (vnp = adp->anp_list; vnp != NULL; vnp = vnp->next) {

2921

anp = (AlignNodePtr) vnp->data.ptrvalue;

2922

if ( anp != NULL ) {

2923

if ( anp->segs->cnp == NULL ) {

2924

slp = CollectSeqLocFromAlignNode (anp);

2925

CollectFeatureForAlign (slp, anp, adp->featOrder, adp->groupOrder);

2926

adp->seqfeat=CollectFeatureForEditor (slp, adp->seqfeat, anp->seq_entityID, anp->bsp_itemID, adp->featOrder, FALSE);

2927

seq_select = TRUE;

2928

}

2929

}

2930

}

2931

if (!seq_select) {

2932

switch_featOrder (adp, 0);

2933

return FALSE;

2934

}

2935

OrderFeatProc (adp->anp_list);

2936

if (adp->seqfeat != NULL)

2937

checkselectsequinfeature_for_editor (adp->seqfeat);

2938

return TRUE;

2939

}

2940

2941

/***********************************************************

2942

***

2943

*** HideFeatureProc

2944

***

2945

*** loop on Bioseq to delete the features in those selected only.

2946

***

2947

***********************************************************/

2948

extern Boolean HideFeatureFunc (EditAlignDataPtr adp)

2949

{

2950

AlignNodePtr anp;

2951

SelStructPtr ssp;

2952

ValNodePtr vnp;

2953

AlignSegPtr asp, aspnext;

2954

Boolean seq_select = FALSE;

2955

2956

switch_featOrder (adp, 0);

2957

if (adp->input_format == OBJ_BIOSEQ)

2958

{

2959

if ( checkOMss_for_itemtype (OBJ_BIOSEQ) == 0 )

2960

ssp = &(adp->master);

2961

else ssp = ObjMgrGetSelected();

2962

for (; ssp != NULL; ssp = ssp->next) {

2963

if ( checkssp_for_editor (ssp) && ssp->itemtype == OBJ_BIOSEQ ) {

2964

adp->seqfeat =SeqfeatlistFree_fromID (adp->seqfeat, ssp->entityID);

2965

anp = (AlignNodePtr) AlignNodeFind (adp->anp_list, ssp->entityID, ssp->itemID, ssp->itemtype);

2966

if ( anp != NULL ) {

2967

asp = anp->segs;

2968

while(asp !=NULL)

2969

{

2970

aspnext = asp->next;

2971

if(asp->cnp != NULL)

2972

FreeFeatureList(asp->cnp);

2973

asp->cnp = NULL;

2974

if(asp->mismatch)

2975

ValNodeFree(asp->mismatch);

2976

asp->mismatch = NULL;

2977

asp = aspnext;

2978

}

2979

seq_select = TRUE;

2980

}

2981

}

2982

}

2983

}

2984

else if (adp->input_format == OBJ_SEQALIGN)

2985

{

2986

for (vnp = adp->anp_list; vnp != NULL; vnp = vnp->next) {

2987

anp = (AlignNodePtr) vnp->data.ptrvalue;

2988

if ( anp != NULL ) {

2989

asp = anp->segs;

2990

while(asp !=NULL)

2991

{

2992

aspnext = asp->next;

2993

if(asp->cnp != NULL)

2994

FreeFeatureList(asp->cnp);

2995

asp->cnp = NULL;

2996

if(asp->mismatch)

2997

ValNodeFree(asp->mismatch);

2998

asp->mismatch = NULL;

2999

asp = aspnext;

3000

}

3001

seq_select = TRUE;

3002

}

3003

}

3004

if (seq_select) adp->seqfeat =SeqfeatlistFree (adp->seqfeat);

3005

}

3006

if (!seq_select) {

3007

switch_featOrder (adp, 1);

3008

return FALSE;

3009

}

3010

return TRUE;

3011

}

3012

3013

/***********************************************************

3014

***

3015

*** ResetFeatureProc

3016

***

3017

***********************************************************/

3018

extern Boolean ResetFeatureFunc (EditAlignDataPtr adp)

3019

{

3020

3021

AlignNodePtr anp;

3022

ValNodePtr vnp;

3023

SeqLocPtr slp;

3024

AlignSegPtr asp, aspnext;

3025

Boolean seq_select = FALSE;

3026

3027

switch_featOrder (adp, 1);

3028

ssp = Gettranslation (adp->seqfeat);

3029

adp->seqfeat = SeqfeatlistFree (adp->seqfeat);

3030

for (vnp = adp->anp_list; vnp != NULL; vnp = vnp->next) {

3031

anp = (AlignNodePtr) vnp->data.ptrvalue;

3032

if ( anp != NULL ) {

3033

asp = anp->segs;

3034

while(asp !=NULL)

3035

{

3036

aspnext = asp->next;

3037

if(asp->cnp != NULL)

3038

FreeFeatureList(asp->cnp);

3039

asp->cnp = NULL;

3040

if(asp->mismatch)

3041

ValNodeFree(asp->mismatch);

3042

asp->mismatch = NULL;

3043

asp = aspnext;

3044

slp = CollectSeqLocFromAlignNode (anp);

3045

CollectFeatureForAlign (slp, anp, adp->featOrder, adp->groupOrder);

3046

adp->seqfeat=CollectFeatureForEditor (slp, adp->seqfeat, anp->seq_entityID, anp->bsp_itemID, adp->featOrder, FALSE);

3047

}

3048

}

3049

}

3050

if (adp->seqfeat !=NULL) {

3051

for (vnp = adp->seqfeat; vnp != NULL; vnp = vnp->next)

3052

{

3053

if (vnp->choice == SEQFEAT_CDREGION) {

3054

cds = (SelEdStructPtr) vnp->data.ptrvalue;

3055

if (cds->entityID == ssp->entityID && cds->itemID == ssp->itemID)

3056

{

3057

if (sesp_to_pept(cds, (SeqAlignPtr) adp->sap_align->data, adp->

3058

sqloc_list, TRUE))

3059

}

3060

}

3061

}

3062

}

3063

3064

return TRUE;

3065

}

3066

3067

/******************************************************************/

3068

static SelEdStructPtr split_feat (SelEdStructPtr feat, Int4 pos, Int4 changevalue)

3069

{

3070

SeqLocPtr slpfeat;

3071

SeqIntPtr sitfeat;

3072

SelEdStructPtr new, next;

3073

Int4 from , to;

3074

3075

slpfeat = (SeqLocPtr) feat->region;

3076

next = feat->next;

3077

if (changevalue >= 0)

3078

from = (Int4)(pos + changevalue);

3079

else {

3080

from = pos;

3081

}

3082

to = (Int4)(SeqLocStop(slpfeat) + changevalue);

3083

sitfeat = (SeqIntPtr) slpfeat->data.ptrvalue;

3084

sitfeat->to = pos -1;

3085

new = new_seledstruct (feat->entityID, feat->itemID, feat->itemtype, 0, feat->bsp_itemID, from, to, SeqLocId (slpfeat), SeqLocStrand (slpfeat), FALSE, feat->label, feat->data, feat->offset + SeqLocLen(slpfeat), 1);

3086

feat->next = new;

3087

new->next = next;

3088

new->prev = feat;

3089

return new;

3090

}

3091

3092

extern ValNodePtr update_featpept (EditAlignDataPtr adp, ValNodePtr feathead, RecT *rp, SelStructPtr ssp, Int4 changevalue, Uint2 itemsubtype)

3093

{

3094

ValNodePtr vnpfeat,

3095

vnpfeatnext;

3096

SelEdStructPtr feat,

3097

feat1, next;

3098

SeqLocPtr slpfeat;

3099

SeqLocPtr slpssp;

3100

SeqIntPtr sitfeat;

3101

Int4 width;

3102

Int4 lg;

3103

Boolean overlap, precede, succeed, deletefeat;

3104

3105

if (ssp == NULL) return feathead;

3106

if (ssp->regiontype == 0 || ssp->region == NULL) return feathead;

3107

slpssp = (SeqLocPtr) ssp->region;

3108

if (SeqLocStart(slpssp) == SeqLocStop(slpssp)) return feathead;

3109

width = adp->visibleWidth;

3110

if (adp->columnpcell > 0)

3111

width += (Int2) adp->visibleWidth / (Int2) adp->columnpcell;

3112

vnpfeat = feathead;

3113

while (vnpfeat != NULL)

3114

{

3115

vnpfeatnext = vnpfeat->next;

3116

feat1 = (SelEdStructPtr) vnpfeat->data.ptrvalue;

3117

if( feat1 != NULL && (vnpfeat->choice ==itemsubtype || itemsubtype == 255))

3118

{

3119

feat = feat1;

3120

while (feat != NULL)

3121

{

3122

next = feat->next;

3123

slpfeat = (SeqLocPtr) feat->region;

3124

overlap = overlapp_ssp (slpssp, slpfeat);

3125

precede = precede_ssp (slpssp, slpfeat);

3126

succeed = succeed_ssp (slpssp, slpfeat);

3127

deletefeat = FALSE;

3128

if (overlap || precede || succeed )

3129

{

3130

sitfeat = (SeqIntPtr) slpfeat->data.ptrvalue;

3131

if (precede)

3132

{

3133

sitfeat->from = sitfeat->from + changevalue ;

3134

sitfeat->to = sitfeat->to + changevalue ;

3135

}

3136

else if (succeed)

3137

{

3138

if (changevalue < 0 ) sitfeat->to =sitfeat->to +changevalue ;

3139

}

3140

else if (overlap)

3141

{

3142

if (changevalue < 0)

3143

{

3144

if ( include_ssp (slpssp, slpfeat) ) {

3145

deletefeat = TRUE;

3146

feathead = del_ssp_fromid (feathead, itemsubtype, feat);

3147

if (rp != NULL)

3148

inval_rect (rp->left, rp->top, rp->right, rp->bottom);

3149

}

3150

else if ( include_ssp (slpfeat, slpssp) ) {

3151

if (!adp->spliteditmode)

3152

sitfeat->to = sitfeat->to + changevalue;

3153

else

3154

feat=split_feat(feat,SeqLocStart(slpssp), changevalue);

3155

}

3156

else if ((lg = overlapp_startssp (slpssp, slpfeat)) > 0) {

3157

if (changevalue < 0) {

3158

sitfeat->from = sitfeat->from - (abs(changevalue)-lg);

3159

sitfeat->to = sitfeat->to + changevalue;

3160

}

3161

else

3162

ErrPostEx (SEV_ERROR, 0, 0, "Cut what ?");

3163

}

3164

else if ((lg = overlapp_startssp (slpfeat, slpssp)) > 0) {

3165

if (changevalue < 0) {

3166

sitfeat->to = sitfeat->to - lg ;

3167

}

3168

else sitfeat->to = sitfeat->to + lg ;

3169

}

3170

}

3171

else {

3172

if (!adp->spliteditmode)

3173

sitfeat->to = sitfeat->to + changevalue ;

3174

else {

3175

feat = split_feat (feat, SeqLocStart(slpssp), changevalue);

3176

}

3177

}

3178

}

3179

if (!deletefeat && rp != NULL)

3180

{

3181

inval_selstruct(adp, feat->entityID, feat->itemID, feat->itemtype, itemsubtype, rp, adp->margin.left,(Int2)(width *adp->charw));

3182

inval_selstruct(adp, feat->entityID, feat->itemID, feat->itemtype, itemsubtype, rp, adp->margin.left, (Int2)(width *adp->charw));

3183

}

3184

}

3185

feat = next;

3186

}

3187

if (feat1 != NULL)

3188

if (feat1->data != NULL)

3189

sesp_to_pept (feat1, (SeqAlignPtr) adp->sap_align->data, adp->sqloc_list, TRUE);

3190

}

3191

vnpfeat = vnpfeatnext;

3192

}

3193

return feathead;

3194

}

3195

3196

static Boolean anpp_has_feature (ValNodePtr anp_list)

3197

{

3198

ValNodePtr vnp;

3199

AlignNodePtr anp;

3200

AlignSegPtr asp;

3201

Boolean featb;

3202

3203

for (vnp = anp_list; vnp != NULL; vnp = vnp->next) {

3204

anp = (AlignNodePtr)vnp->data.ptrvalue;

3205

featb = FALSE;

3206

if(anp != NULL)

3207

{

3208

for(asp = anp->segs; asp != NULL; asp = asp->next) {

3209

if(asp->cnp != NULL) {

3210

featb = TRUE;

3211

break;

3212

}

3213

}

3214

}

3215

if (featb)

3216

return TRUE;

3217

}

3218

return FALSE;

3219

}

3220

3221

extern void ShowFeatureProc (PaneL pnl, Boolean invalidate)

3222

{

3223

WindoW temport;

3224

SeqEditViewFormPtr wdp;

3225

EditAlignDataPtr adp;

3226

Boolean ok;

3227

float hratio;

3228

3229

wdp = (SeqEditViewFormPtr)GetObjectExtra (ParentWindow(pnl));

3230

if ( wdp == NULL ) return;

3231

if ( ( adp = GetAlignDataPanel (pnl) ) == NULL ) return;

3232

if ( adp->seqnumber == 0 ) return;

3233

hratio = (float)adp->hoffset / (float)adp->length;

3234

adp->showfeat = (!adp->showfeat);

3235

ResetClip ();

3236

WatchCursor ();

3237

if ( adp->showfeat ) {

3238

ok = TRUE;

3239

if (!anpp_has_feature (adp->anp_list))

3240

ok = (Boolean) ShowFeatureFunc (adp);

3241

if (ok) {

3242

Enable (wdp->hidefeatitem);

3243

Disable(wdp->showfeatitem);

3244

SetTitle (wdp->showfeatbt, "Hide Feat.");

3245

}

3246

}

3247

else {

3248

ok = TRUE;

3249

if (anpp_has_feature (adp->anp_list))

3250

ok = (Boolean) HideFeatureFunc (adp);

3251

if (ok) {

3252

Disable (wdp->hidefeatitem);

3253

Enable(wdp->showfeatitem);

3254

SetTitle (wdp->showfeatbt, "Show Feat.");

3255

}

3256

}

3257

if (ok) {

3258

3259

data_collect_arrange (adp, TRUE);

3260

SeqEdSetCorrectBarMax (pnl, adp, hratio);

3261

if (invalidate) {

3262

temport = SavePort(ParentWindow(pnl));

3263

Select (pnl);

3264

inval_panel (pnl, -1, -1);

3265

RestorePort (temport);

3266

}

3267

}

3268

ArrowCursor ();

3269

}

3270

3271

/******************************************************

3272

***

3273

*** LaunchCDSEditor on a Bioseq (input_itemID)

3274

***

3275

*******************************************************/

3276

static void LaunchCDSEditor (Uint2 input_entityID, Uint2 input_itemID, SeqLocPtr slp, Uint1 codonstart)

3277

{

3278

WindoW w;

3279

SeqEntryPtr top_sep;

3280

FeatureFormPtr cfp;

3281

3282

if (slp != NULL && input_entityID != 0)

3283

{

3284

top_sep = GetTopSeqEntryForEntityID (input_entityID);

3285

input_entityID = SeqMgrGetEntityIDForSeqEntry (top_sep);

3286

3287

w = (WindoW) CreateCdRgnForm (-50, -33, "Coding Region", NULL, top_sep, CdRgnFeatFormActnProc);

3288

cfp = (FeatureFormPtr) GetObjectExtra (w);

3289

if (cfp != NULL) {

3290

cfp->input_entityID = input_entityID;

3291

cfp->input_itemID = input_itemID;

3292

cfp->input_itemtype = OBJ_BIOSEQ;

3293

cfp->this_itemtype = OBJ_SEQFEAT;

3294

cfp->this_subtype = FEATDEF_CDS;

3295

PointerToForm (cfp->form, NULL);

3296

SendMessageToForm (cfp->form, VIB_MSG_INIT);

3297

PointerToDialog (cfp->location, (Pointer) slp);

3298

CdRgnTranslateWithFrame (cfp->form, 1);

3299

}

3300

Show (w);

3301

Select (w);

3302

}

3303

return;

3304

}

3305

/***************************************************************

3306

*** slpfeatreplacefunc

3307

***

3308

*****************************************************************/

3309

static Boolean slpfeatreplacefunc(GatherContextPtr gcp)

3310

{

3311

SeqFeatPtr sfp;

3312

SeqLocPtr slp;

3313

Boolean p3, p5;

3314

3315

if(gcp->thistype != OBJ_SEQFEAT)

3316

return FALSE;

3317

sfp = (SeqFeatPtr)(gcp->thisitem);

3318

slp = (SeqLocPtr) gcp->userdata;

3319

CheckSeqLocForPartial (sfp->location, &p5, &p3);

3320

SetSeqLocPartial (slp, p5, p3);

3321

sfp->location = SeqLocFree (sfp->location);

3322

sfp->location = slp;

3323

return TRUE;

3324

}

3325

3326

/******************************************************************

3327

***

3328

*** SaveFeatProc

3329

*** look at the selected items

3330

*** if new feature, attaches it (AttachDataForProc)

3331

*** other, replaces it (GatherItem)

3332

*** sends a message to ObjMgr (ObjMgrSendMsg (OM_MSG_UPDATE..))

3333

*** write the seqenrty in the temporary file

3334

***

3335

*** SaveFeatureProc, SaveFeatureButton : call SaveFeatProc

3336

*** sends a message to ObjMgr (ObjMgrSendMsg (OM_MSG_UPDATE..))

3337

***

3338

*******************************************************************/

3339

extern void SaveFeatProc (PaneL pnl)

3340

{

3341

EditAlignDataPtr adp;

3342

SeqEntryPtr sep;

3343

SelStructPtr ssp = NULL;

3344

SelEdStructPtr feat;

3345

ValNodePtr vnp,

3346

next;

3347

SeqLocPtr slp;

3348

RecT rp;

3349

Int2 width;

3350

Uint2 bsp_eID, bsp_iID;

3351

Int2 handled;

3352

3353

if ( ( adp = GetAlignDataPanel (pnl) ) == NULL ) return;

3354

if ( adp->seqnumber == 0 ) return;

3355

if ( checkOMss_for_itemtype (OBJ_VIRT) == 0

3356

&& checkOMss_for_itemtype (OBJ_SEQFEAT) == 0 ) return;

3357

sep = GetBestTopParentForItemID (adp->master.entityID, adp->master.itemID, adp->master.itemtype);

3358

if (sep == NULL)

3359

return;

3360

ssp = ObjMgrGetSelected();

3361

for (; ssp != NULL; ssp = ssp->next)

3362

{

3363

if ( checkssp_for_editor (ssp) && ssp->itemtype == OBJ_VIRT)

3364

{

3365

vnp = adp->feat;

3366

while (vnp != NULL) {

3367

next = vnp->next;

3368

if (vnp->choice == SEQFEAT_CDREGION) {

3369

feat = (SelEdStructPtr) vnp->data.ptrvalue;

3370

if ( is_samess_ses (ssp, feat) )

3371

{

3372

if (SeqLocStart((SeqLocPtr)feat->region)==0 || feat->codonstart == 1)

3373

{

3374

adp->curfeat = feat;

3375

slp = sesp_to_slp (feat, (SeqAlignPtr) adp->sap_align->data, adp->sqloc_list, FALSE);

3376

bsp_eID = SeqMgrGetEntityIDForSeqEntry (sep);

3377

bsp_iID = feat->bsp_itemID;

3378

LaunchCDSEditor (bsp_eID, bsp_iID, slp, feat->codonstart);

3379

}

3380

else

3381

ErrPostEx (SEV_ERROR, 0, 0, "Codon start must be 1");

3382

break;

3383

}

3384

}

3385

}

3386

vnp = next;

3387

}

3388

else if ( checkssp_for_editor (ssp) && ssp->itemtype == OBJ_SEQFEAT)

3389

{

3390

vnp = adp->seqfeat;

3391

while (vnp != NULL)

3392

{

3393

next = vnp->next;

3394

if (vnp->choice == SEQFEAT_CDREGION

3395

|| vnp->choice == SEQFEAT_GENE || vnp->choice == SEQFEAT_RNA)

3396

{

3397

feat = (SelEdStructPtr) vnp->data.ptrvalue;

3398

if ( is_samess_ses (ssp, feat) )

3399

{

3400

slp = sesp_to_slp (feat,(SeqAlignPtr) adp->sap_align->data, adp->sqloc_list, FALSE);

3401

if (slp != NULL)

3402

{

3403

bsp_eID = feat->entityID;

3404

bsp_iID = feat->itemID;

3405

GatherItem (bsp_eID, bsp_iID, OBJ_SEQFEAT, (Pointer)(slp), slpfeatreplacefunc);

3406

ObjMgrSendMsg (OM_MSG_UPDATE, adp->master.entityID, adp->master.itemID, adp->master.itemtype);

3407

HideFeatureFunc (adp);

3408

adp->showfeat = FALSE;

3409

ShowFeatureProc(pnl, FALSE);

3410

get_client_rect (pnl, &rp);

3411

width = adp->visibleWidth;

3412

if (adp->columnpcell > 0)

3413

width +=(Int2)adp->visibleWidth/(Int2) adp->columnpcell;

3414

inval_all (adp, &rp, (Uint2)255, OBJ_VIRT, OBJ_SEQFEAT, width);

3415

3416

WatchCursor ();

3417

Update ();

3418

handled = GatherProcLaunch (OMPROC_EDIT, FALSE, bsp_eID, bsp_iID, OBJ_SEQFEAT, 0, 0, OBJ_SEQFEAT, 0);

3419

ArrowCursor ();

3420

Update ();

3421

}

3422

break;

3423

}

3424

}

3425

vnp = next;

3426

}

3427

seqentry_write (sep, adp->tmpfile);

3428

}

3429

}

3430

adp->dirty = TRUE;

3431

if (!adp->showfeat) {

3432

ShowFeatureProc(pnl, TRUE);

3433

}

3434

return;

3435

}

3436

3437

/******************************************************************

3438

***

3439

*** SaveAllFeatProc

3440

*** looks at the features items

3441

*** attaches the new features (AttachDataForProc)

3442

*** replaces the old features (GatherItem)

3443

***

3444

OLD VERSION:

3445

3446

OMProcControl ompc;

3447

EditAlignDataPtr adp;

3448

SelEdStructPtr feat;

3449

ValNodePtr vnp;

3450

SeqLocPtr slp;

3451

3452

if ( ( adp = GetAlignDataPanel (pnl) ) == NULL ) return;

3453

if ( adp->seqnumber == 0 ) return;

3454

3455

MemSet ((Pointer) &ompc, 0, sizeof (OMProcControl));

3456

ompc.input_entityID = adp->master.entityID;

3457

ompc.input_itemID = adp->master.itemID;

3458

ompc.input_itemtype = adp->master.itemtype;

3459

ompc.output_itemtype = OBJ_SEQFEAT;

3460

3461

for (vnp=adp->seqfeat; vnp != NULL; vnp = vnp->next)

3462

{

3463

if (vnp->choice == SEQFEAT_CDREGION

3464

|| vnp->choice == SEQFEAT_GENE || vnp->choice == SEQFEAT_RNA) {

3465

feat = (SelEdStructPtr) vnp->data.ptrvalue;

3466

slp = sesp_to_slp (feat, (SeqAlignPtr) adp->sap_align->data, FALSE);

3467

if (slp != NULL) {

3468

GatherItem (feat->entityID, feat->itemID, OBJ_SEQFEAT,

3469

(Pointer)(slp), slpfeatreplacefunc);

3470

}

3471

}

3472

}

3473

*******************************************************************/

3474

extern void SaveAllFeatProc (PaneL pnl)

3475

{

3476

return;

3477

}

3478

3479

3480

static void MakeFeatFunc (EditAlignDataPtr adp, SelStructPtr ssp, Uint2 itemsubtype, Uint1 strand)

3481

{

3482

SelEdStructPtr feat = NULL;

3483

SelStructPtr ssptmp;

3484

SeqLocPtr slp;

3485

SeqIntPtr sit;

3486

SeqLocPtr slpfeat;

3487

Int4 from, to;

3488

Uint2 itemID;

3489

3490

slp = (SeqLocPtr) ssp->region;

3491

ssptmp = is_selectedbyID (ssp->entityID, 255, OBJ_VIRT);

3492

if (ssptmp == NULL) {

3493

adp->nfeat++;

3494

itemID = adp->nfeat;

3495

} else {

3496

itemID = ssptmp->itemID;

3497

}

3498

from = SeqLocStart (slp);

3499

to = SeqLocStop (slp);

3500

if (to == APPEND_RESIDUE) {

3501

slpfeat = ValNodeNew (NULL);

3502

slpfeat->choice = SEQLOC_WHOLE;

3503

slpfeat->data.ptrvalue = (Pointer) SeqIdDup (SeqLocId(slp));

3504

to = SeqLocLen(slpfeat) -1;

3505

SeqLocFree (slpfeat);

3506

}

3507

if (from >= 0 && to > 0) {

3508

sit = (SeqIntPtr) slp->data.ptrvalue;

3509

sit->strand = strand;

3510

feat = ss_to_ses (ssp);

3511

slpfeat = (SeqLocPtr)feat->region;

3512

setposition_toses (feat, from, to);

3513

3514

/* feat->entityID !!!!!!!!!!!!!!!!!!!!!*/

3515

feat->bsp_itemID = feat->itemID;

3516

feat->itemID = itemID;

3517

feat->itemtype = OBJ_VIRT;

3518

feat->codonstart = 1;

3519

feat->offset = 0;

3520

feat->dirty = TRUE;

3521

feat->next = NULL;

3522

feat->prev = NULL;

3523

adp->feat = AddFeatFunc (feat, &(adp->feat), itemsubtype);

3524

}

3525

}

3526

3527

extern void MakeFeatProc (PaneL pnl, Uint2 itemsubtype, Uint1 strand)

3528

{

3529

WindoW temport;

3530

EditAlignDataPtr adp;

3531

SelStructPtr ssp;

3532

float hratio;

3533

3534

if ( ( adp = GetAlignDataPanel (pnl) ) != NULL ) {

3535

if (adp->seqnumber > 0 || ISA_na(adp->mol_type)) {

3536

hratio = (float)adp->hoffset / (float)adp->length;

3537

ssp = ObjMgrGetSelected();

3538

for (; ssp != NULL; ssp = ssp->next)

3539

{

3540

if (checkssp_for_editor (ssp) && ssp->itemtype == OBJ_BIOSEQ ) {

3541

MakeFeatFunc (adp, ssp, itemsubtype, strand);

3542

}

3543

}

3544

data_collect_arrange (adp, TRUE);

3545

SeqEdSetCorrectBarMax (pnl, adp, hratio);

3546

adp->dirty = TRUE;

3547

temport = SavePort(ParentWindow(pnl));

3548

Select (pnl);

3549

inval_panel (pnl, -1, -1);

3550

RestorePort (temport);

3551

}

3552

}

3553

return;

3554

}

3555

3556

extern void TranslateAllBioseq (PaneL pnl, EditAlignDataPtr adp)

3557

{

3558

WindoW temport;

3559

SelEdStructPtr cds;

3560

AlignNodePtr anp;

3561

SelStructPtr ssp;

3562

SeqLocPtr slp;

3563

ValNodePtr vnp = NULL;

3564

float hratio;

3565

3566

hratio = (float)adp->hoffset / (float)adp->length;

3567

if (adp->seqnumber > 0 || ISA_na(adp->mol_type)) {

3568

for (vnp = adp->anp_list; vnp != NULL; vnp = vnp->next) {

3569

if ( (anp = (AlignNodePtr) vnp->data.ptrvalue) != NULL)

3570

{

3571

slp = CollectSeqLocFromAlignNode(anp);

3572

if (slp!=NULL) {

3573

ssp = SelStructNew (anp->seq_entityID, anp->bsp_itemID, OBJ_BIOSEQ, SeqLocStart(slp), SeqLocStop(slp), SeqLocId(slp), SeqLocStrand(slp), FALSE);

3574

if (ssp!=NULL)

3575

MakeFeatFunc (adp, ssp, SEQFEAT_CDREGION, Seq_strand_plus);

3576

}

3577

}

3578

}

3579

vnp = adp->feat;

3580

if (vnp != NULL)

3581

{

3582

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

3583

{

3584

if (vnp->choice == FEATDEF_CDS) {

3585

cds = (SelEdStructPtr) vnp->data.ptrvalue;

3586

sesp_to_pept(cds, (SeqAlignPtr) adp->sap_align->data, adp->sqloc_list, TRUE);

3587

}

3588

}

3589

data_collect_arrange (adp, TRUE);

3590

SeqEdSetCorrectBarMax (pnl, adp, hratio);

3591

temport = SavePort(ParentWindow(pnl));

3592

Select (pnl);

3593

inval_panel (pnl, -1, -1);

3594

RestorePort (temport);

3595

}

3596

}

3597

return;

3598

}

3599

/**************************************/

3600

/**************************************/

3601

/**************************************/

3602

/**************************************/

3603

/**************************************/

3604

3605

static void FindBioseqCB3 (SeqEntryPtr sep, Pointer mydata,

3606

Int4 index, Int2 indent)

3607

{

3608

ValNodePtr vnp;

3609

3610

if (sep != NULL && sep->data.ptrvalue && mydata != NULL) {

3611

if (IS_Bioseq(sep)) {

3612

vnp = (ValNodePtr)mydata;

3613

if (vnp->data.ptrvalue==NULL)

3614

{

3615

vnp->data.ptrvalue=(BioseqPtr) sep->data.ptrvalue;

3616

}

3617

}

3618

}

3619

}

3620

3621

static SelEdStructPtr is_sip_inseqinfo (SeqIdPtr sip, SelEdStructPtr seq_info)

3622

{

3623

SelEdStructPtr tmp;

3624

SeqLocPtr slp;

3625

3626

for (tmp=seq_info; tmp!=NULL; tmp=tmp->next)

3627

{

3628

slp=(SeqLocPtr)tmp->region;

3629

if (SeqIdForSameBioseq (sip, SeqLocId(slp)))

3630

{

3631

return tmp;

3632

}

3633

}

3634

return NULL;

3635

}

3636

3637

extern ValNodePtr CCReadAnythingLoop (CharPtr filename, SelEdStructPtr seq_info)

3638

{

3639

Char name [PATH_MAX];

3640

Pointer dataptr;

3641

FILE *fp;

3642

BioseqPtr bsp;

3643

SeqEntryPtr sep;

3644

SeqLocPtr slp;

3645

ValNodePtr head = NULL,

3646

vnp,

3647

slphead = NULL;

3648

Uint2 datatype;

3649

Uint2 entityID;

3650

3651

ValNode vn;

3652

3653

SelEdStructPtr tmp;

3654

3655

if (filename == NULL)

3656

{

3657

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

3658

return NULL;

3659

}

3660

filename = name;

3661

}

3662

fp = FileOpen (filename, "r");

3663

if (fp != NULL) {

3664

while ((dataptr = ReadAsnFastaOrFlatFile (fp, &datatype, NULL, FALSE, FALSE, TRUE, FALSE)) != NULL) {

3665

ValNodeAddPointer (&head, datatype, dataptr);

3666

}

3667

FileClose (fp);

3668

for (vnp = head; vnp != NULL; vnp = vnp->next) {

3669

datatype = vnp->choice;

3670

dataptr = vnp->data.ptrvalue;

3671

entityID = ObjMgrRegister (datatype, dataptr);

3672

if (datatype == OBJ_BIOSEQ)

3673

{

3674

bsp=(BioseqPtr)vnp->data.ptrvalue;

3675

slp = SeqLocIntNew (0, bsp->length-1, Seq_strand_plus, SeqIdFindBest (bsp->id, 0));

3676

3677

if (seq_info) {

3678

if ((tmp=is_sip_inseqinfo(bsp->id, seq_info)) != NULL) {

3679

sep=SeqEntryNew ();

3680

sep->choice=1;

3681

sep->data.ptrvalue = (Pointer)bsp;

3682

SeqEntryReplaceSeqID (sep, SeqLocId(slp));

3683

ValNodeFree(slp);

3684

slp = SeqLocIntNew(0, bsp->length-1, Seq_strand_plus, bsp->id);

3685

sep->data.ptrvalue = NULL;

3686

SeqEntryFree(sep);

3687

}

3688

}

3689

ValNodeAddPointer (&slphead, 0, (Pointer) slp);

3690

}

3691

else if (datatype == OBJ_SEQENTRY)

3692

{

3693

sep=(SeqEntryPtr)vnp->data.ptrvalue;

3694

vn.data.ptrvalue=NULL;

3695

SeqEntryExplore (sep, &vn, FindBioseqCB3);

3696

if (vn.data.ptrvalue!=NULL) {

3697

bsp=(BioseqPtr)vn.data.ptrvalue;

3698

slp = SeqLocIntNew (0, bsp->length-1, Seq_strand_plus, SeqIdFindBest (bsp->id, 0));

3699

3700

if (seq_info) {

3701

if ((tmp=is_sip_inseqinfo(bsp->id, seq_info)) != NULL) {

3702

SeqEntryReplaceSeqID (sep, SeqLocId(slp));

3703

ValNodeFree(slp);

3704

slp = SeqLocIntNew(0, bsp->length-1, Seq_strand_plus, bsp->id);

3705

}

3706

}

3707

ValNodeAddPointer (&slphead, 0, (Pointer) slp);

3708

}

3709

}

3710

}

3711

}

3712

return slphead;

3713

}

3714

3715

3716

3717

3718

3719

3720

3721

/*******************************************************

3722

*** AsnReadForSalsa

3723

*** copied from Jonathan's code

3724

*** without the following lines:

3725

***

3726

rsult = SeqEntryNew ();

3727

if (rsult != NULL) {

3728

rsult->choice = sep->choice;

3729

rsult->data.ptrvalue = sep->data.ptrvalue;

3730

sep->data.ptrvalue = NULL;

3731

if (datatype == OBJ_SEQSUB) {

3732

SeqSubmitFree ((SeqSubmitPtr) dataptr);

3733

} else {

3734

SeqEntryFree (sep);

3735

}

3736

if (!ObjMgrRegister (OBJ_SEQENTRY, (Pointer) rsult))

3737

rsult = SeqEntryFree (rsult);

3738

}

3739

***********************************************************/

3740

extern SeqEntryPtr AsnReadForSalsa (CharPtr path)

3741

{

3742

Char name[PATH_MAX];

3743

BioseqPtr bsp;

3744

BioseqSetPtr bssp;

3745

Pointer dataptr;

3746

Uint2 datatype;

3747

Uint2 entityID;

3748

SeqEntryPtr rsult;

3749

SeqEntryPtr sep;

3750

Boolean delete_sep=FALSE;

3751

3752

rsult = NULL;

3753

if (path == NULL) {

3754

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

3755

return NULL;

3756

}

3757

path = name;

3758

}

3759

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

3760

dataptr = ObjMgrGenericAsnTextFileRead (path, &datatype, &entityID);

3761

if (dataptr != NULL && entityID > 0) {

3762

if (datatype == OBJ_SEQSUB || datatype == OBJ_SEQENTRY ||

3763

datatype == OBJ_BIOSEQ || datatype == OBJ_BIOSEQSET) {

3764

sep = GetTopSeqEntryForEntityID (entityID);

3765

if (sep == NULL) {

3766

sep = SeqEntryNew ();

3767

if (sep != NULL) {

3768

if (datatype == OBJ_BIOSEQ) {

3769

bsp = (BioseqPtr) dataptr;

3770

sep->choice = 1;

3771

sep->data.ptrvalue = bsp;

3772

SeqMgrSeqEntry (SM_BIOSEQ, (Pointer) bsp, sep);

3773

} else if (datatype == OBJ_BIOSEQSET) {

3774

bssp = (BioseqSetPtr) dataptr;

3775

sep->choice = 2;

3776

sep->data.ptrvalue = bssp;

3777

SeqMgrSeqEntry (SM_BIOSEQSET, (Pointer) bssp, sep);

3778

}

3779

}

3780

sep = GetTopSeqEntryForEntityID (entityID);

3781

delete_sep=TRUE;

3782

}

3783

if (sep != NULL) {

3784

rsult = (SeqEntryPtr) AsnIoMemCopy((Pointer) sep, (AsnReadFunc)SeqEntryAsnRead, (AsnWriteFunc)SeqEntryAsnWrite);

3785

if (delete_sep) {

3786

sep->data.ptrvalue = NULL;

3787

sep = SeqEntryFree (sep);

3788

}

3789

}

3790

}

3791

ObjMgrFree (datatype, (Pointer) dataptr);

3792

}

3793

}

3794

return rsult;

3795

}

3796

3797

extern SeqEntryPtr seqentry_read (CharPtr path)

3798

{

3799

Char name[PATH_MAX];

3800

AsnIoPtr aip;

3801

AsnTypePtr atp;

3802

AsnModulePtr amp;

3803

SeqEntryPtr sep;

3804

3805

if (path == NULL )

3806

{

3807

if (! GetInputFileName (name, PATH_MAX,"","TEXT")) {

3808

return NULL;

3809

}

3810

path = name;

3811

}

3812

amp = AsnAllModPtr ();

3813

atp = AsnTypeFind (amp,"SeqEntry");

3814

if ((aip = AsnIoOpen (path,"r")) == NULL) {

3815

return NULL;

3816

}

3817

sep = SeqEntryAsnRead ( aip, atp );

3818

aip = AsnIoClose (aip);

3819

return sep;

3820

}

3821

3822

3823

3824

3825

Older »