libncbi6-dev 6.1.20120620-10 / usr / include / ncbi / samutil.h

/*   $Id: samutil.h,v 1.59 2001/01/24 23:04:01 hurwitz Exp $
* ===========================================================================
*
*                            PUBLIC DOMAIN NOTICE
*            National Center for Biotechnology Information (NCBI)
*
*  This software/database is a "United States Government Work" under the
*  terms of the United States Copyright Act.  It was written as part of
*  the author's official duties as a United States Government employee and
*  thus cannot be copyrighted.  This software/database is freely available
*  to the public for use. The National Library of Medicine and the U.S.
*  Government do not place any restriction on its use or reproduction.
*  We would, however, appreciate having the NCBI and the author cited in
*  any work or product based on this material
*
*  Although all reasonable efforts have been taken to ensure the accuracy
*  and reliability of the software and data, the NLM and the U.S.
*  Government do not and cannot warrant the performance or results that
*  may be obtained by using this software or data. The NLM and the U.S.
*  Government disclaim all warranties, express or implied, including
*  warranties of performance, merchantability or fitness for any particular
*  purpose.
*
* ===========================================================================
*
* File Name:  $Id: samutil.h,v 1.59 2001/01/24 23:04:01 hurwitz Exp $
*
* Author:  Lewis Geer
*
* Version Creation Date:   8/12/99
*
* $Revision: 1.59 $
*
* File Description: Utility functions for AlignIds and SeqAlignLocs
*
* Modifications:
* --------------------------------------------------------------------------
* $Log: samutil.h,v $
* Revision 1.59  2001/01/24 23:04:01  hurwitz
* added a couple utility functions
*
* Revision 1.58  2000/11/01 20:50:22  hurwitz
* made functions for get block starts and stops from populated paraGs
*
* Revision 1.57  2000/10/05 21:27:42  hurwitz
* bug fix for making ruler, added functions to get bioseq start and len of each aligned block
*
* Revision 1.56  2000/09/08 21:47:57  hurwitz
* added DDE_GetNumResidues function
*
* Revision 1.55  2000/08/29 18:01:38  lewisg
* fix dde launch logic
*
* Revision 1.54  2000/08/25 22:10:33  hurwitz
* added utility function
*
* Revision 1.53  2000/08/07 23:02:39  hurwitz
* when merging panels fails, scroll to spot where alignments differ
*
* Revision 1.52  2000/08/03 17:12:38  hurwitz
* added functions to check if alignments are mergeable
*
* Revision 1.51  2000/07/25 20:30:22  hurwitz
* bug fixes: panel update when file is closed, double-click launches UDV from DDE, seqName agrees in status line and left col
*
* Revision 1.50  2000/07/17 17:49:12  hurwitz
* fixed bug.  when copying ParaG's need to copy all rows so edits can be saved properly
*
* Revision 1.49  2000/07/05 18:42:17  hurwitz
* added split block function to DDV
*
* Revision 1.48  2000/06/30 22:31:52  hurwitz
* added merge block function for DDV
*
* Revision 1.47  2000/06/15 20:26:06  hurwitz
* added left/right/center justify for DDE
*
* Revision 1.46  2000/06/07 19:09:36  hurwitz
* made DDE_ReMakeRuler work with linked list of ParaGs
*
* Revision 1.45  2000/05/25 21:40:42  hurwitz
* rows hidden in DDV are hidden in DDE, can save edits when rows are hidden in DDE
*
* Revision 1.44  2000/05/19 13:48:32  hurwitz
* made a version of DDE that doesn't allow aligned gaps, changed wording for adding new rows
*
* Revision 1.43  2000/05/16 19:43:02  hurwitz
* grey out create block, delete block, undo, and redo as needed
*
* Revision 1.42  2000/05/15 23:39:33  lewisg
* shred cblast, add menu items for gapped/ungapped, fix pdbheaders
*
* Revision 1.41  2000/05/12 21:18:14  hurwitz
* added window asking if user wants to save unsaved edits for dde
*
* Revision 1.40  2000/05/05 20:24:14  hurwitz
* some bug fixes, also redraw proper block in DDE after a save operation that causes a merge of 2 blocks
*
* Revision 1.39  2000/05/04 22:43:39  hurwitz
* don't launch DDE on top of DDV, change some wording, redraw DDE after save to AlnMgr
*
* Revision 1.38  2000/05/02 19:50:37  hurwitz
* fixed some bugs with launching DDE from DDV, added new alnMgr fn for positioning DDE on proper column
*
* Revision 1.37  2000/04/26 21:53:22  hurwitz
* added save function to tell AlnMgr about edits made in DDE
*
* Revision 1.36  2000/04/21 23:00:51  hurwitz
* can launch DDE from DDV
*
* Revision 1.35  2000/04/13 18:57:03  hurwitz
* for DDE: many bug fixes, also get rid of columns that are all unaligned gaps
*
* Revision 1.34  2000/04/10 21:41:25  lewisg
* move alignment menus into ddv, udv from cn3d
*
* Revision 1.33  2000/04/07 16:21:09  hurwitz
* made delete block faster, added delete block to edit menu
*
* Revision 1.32  2000/04/05 20:52:35  hurwitz
* added GUI control for shifting left and right alignment boundaries
*
* Revision 1.31  2000/04/03 22:26:31  hurwitz
* can now shift a row with click and drag
*
* Revision 1.30  2000/03/29 20:02:48  hurwitz
* keep track of master during move row operations
*
* Revision 1.29  2000/03/28 21:03:14  hurwitz
* added gui control to re-order rows
*
* Revision 1.28  2000/03/25 00:22:10  hurwitz
* put DDE_StackPtr in DDV_Main, add to stack inside DDE api's, added insert char, delete char, home and end keyboard control
*
* Revision 1.27  2000/03/23 00:00:00  hurwitz
* DDE api's are called with stack now
*
* Revision 1.26  2000/03/20 22:22:48  hurwitz
* added more checks to verify subroutine, 1 bug fix
*
* Revision 1.25  2000/03/16 15:51:32  hurwitz
* added function to create an aligned block
*
* Revision 1.24  2000/03/14 22:08:21  hurwitz
* undo and redo working properly, restore-original function added
*
* Revision 1.23  2000/03/10 23:01:43  hurwitz
* added undo and redo functions, first pass
*
* Revision 1.22  2000/03/09 22:28:40  hurwitz
* added shift block and delete block, a bug fix too
*
* Revision 1.21  2000/03/08 22:02:07  hurwitz
* added verify function, debugging, handle align_start != 0
*
* Revision 1.20  2000/03/06 22:45:58  hurwitz
* can shift right boundary of an aligned block left and right, DDVRuler updates added
*
* Revision 1.19  2000/03/01 22:49:40  lewisg
* import bioseq, neatlyindex, get rid of dead code
*
* Revision 1.18  2000/02/29 21:13:06  hurwitz
* added low level functions for shifting left and right the left alignment boundary
*
* Revision 1.17  2000/02/28 16:28:39  hurwitz
* added functions for deleting an aligned gap
*
* Revision 1.16  2000/02/24 23:37:00  hurwitz
* added ability to insert gaps
*
* Revision 1.15  2000/02/18 16:06:22  hurwitz
* for editing multiple sequence alignments: shift row right now working
*
* Revision 1.14  2000/02/15 22:40:57  lewisg
* add ability to launch udv so that it colors by row, fixes to colormgr, track rows from viewmgr, fix visual c projects
*
* Revision 1.13  2000/02/15 17:44:12  hurwitz
* reverted to 1.11
*
* Revision 1.11  2000/02/14 23:09:08  hurwitz
* got rid of calls to DDV_RulerDescrNew() because of library conflicts
*
* Revision 1.10  2000/02/14 20:58:57  hurwitz
* added functions for editing multiple sequence alignments: hide/show row, move row, shift row left
*
* Revision 1.9  2000/01/24 20:54:35  vakatov
* SAM_ViewString::  made #define to fix for the DLL build on PC
*
* Revision 1.8  1999/12/11 01:30:34  lewisg
* fix bugs with sharing colors between ddv and cn3d
*
* Revision 1.7  1999/12/03 23:17:23  lewisg
* Patrick's new global update msg, argument passing when launching ddv, experimental editing
*
* Revision 1.6  1999/11/24 21:24:30  vakatov
* Fixed for the C++ and/or MSVC DLL compilation
*
* Revision 1.5  1999/11/15 18:30:07  lewisg
* get rid of extra redraws when selecting
*
* Revision 1.4  1999/10/05 23:18:16  lewisg
* add ddv and udv to cn3d with memory management
*
* Revision 1.3  1999/09/27 17:49:12  lewisg
* fix denseseg constructor, bug in valnode loops, add SAM_ValNodeByPosition
*
* Revision 1.2  1999/09/21 19:38:59  lewisg
* update broken declarations
*
* Revision 1.1  1999/09/21 18:09:14  lewisg
* binary search added to color manager, various bug fixes, etc.
*
* Revision 1.3  1999/09/03 14:01:40  lewisg
* use faster seqid compare SAM_CompareID
*
* Revision 1.2  1999/09/01 23:02:59  lewisg
* binary search in color functions
*
* Revision 1.1  1999/08/13 22:08:16  lewisg
* color manager updated to use alignment coords
*
*
* ==========================================================================
*/


#ifndef SAMUTIL_H
#define SAMUTIL_H

#include <ncbistd.h>
#include <objall.h>
#include <sequtil.h>
#include <objgen.h>
#include <objalignloc.h>
#include <pgppop.h>    /*-- dih*/

#undef NLM_EXTERN
#ifdef NLM_IMPORT
#define NLM_EXTERN NLM_IMPORT
#else
#define NLM_EXTERN extern
#endif

#ifdef __cplusplus
extern "C" {
#endif


#define SAM_SIPBUF 80

#define SAM_NOLAP 0x1
#define SAM_NOLAPFRONT 0x3
#define SAM_NOLAPBACK 0x5
#define SAM_TOTALLAP 0x8
#define SAM_FRONTLAP 0x10
#define SAM_BACKLAP 0x20

#define ThrowError if(!Nlm_ErrSetContext(THIS_MODULE,THIS_FILE,__LINE__,DBFLAG,0,0,0)) goto error
#define ErrorReturn(error, string, retval) {Nlm_ErrSetContext(THIS_MODULE,THIS_FILE,__LINE__,DBFLAG,0,0,0); \
    Nlm_ErrPostEx((error), 0, 0, (string)); Nlm_ErrShow(); return(retval);}
#define ErrorReturnVoid(error, string) {Nlm_ErrSetContext(THIS_MODULE,THIS_FILE,__LINE__,DBFLAG,0,0,0); \
    Nlm_ErrPostEx((error), 0, 0, (string)); Nlm_ErrShow(); return;}
    
typedef Boolean (*StartNetworkProc) (Boolean UseNetwork);
typedef SeqEntryPtr (*SAM_SeqFetchProc) (Int4 uid, Int2 retcode);

/* same as Vibrant RecT */
typedef  struct  _SAM_RecT {
  Nlm_Int2  left;
  Nlm_Int2  top;
  Nlm_Int2  right;
  Nlm_Int2  bottom;
} SAM_RecT, PNTR SAM_RecTPtr;

/* defines so that views can be identified */
#define SAMVIEWSELF 0
#define SAMVIEWCN3D 1
#define SAMVIEWDDV 2
#define SAMVIEWUDV 3
#define SAMVIEWSEQUIN 4
#define SAMVIEWNENTREZ 5
#define SAMVIEWDDE 6
#define SAMVIEWCN3DDDV 7

#define SAM_ViewString "Viewer Global"

typedef  struct  _SAM_ViewerGlobal {
  SAM_RecT Rect;  /* where the master viewer wants the called viewer to go */
  SAM_SeqFetchProc  FetchProc;  /* the fetch function the master has set */
  Int4 MasterViewer;  /* the name of the master viewer */
  DDV_ColorGlobal *pCGlobal;
  Int4 Row;
  StartNetworkProc NetStartProc;
  void *BlastFile;
  void *BlastNet;
  void *BlastFileGap;
  void *BlastNetGap;
  void *BlastMany;
} SAM_ViewGlobal, PNTR SAM_ViewGlobalPtr;


/*----------------------------------------------------------------------------
*  This is where I'm going to put my code for now...   Dave Hurwitz
*                                                      1/21/00
*
*  These are the structutes and functions needed for the multiple
*  alignment editor.  Perhaps it will be called DDE (as opposed to
*  DDV).  (2-d editor, rather than 2-d viewer).
*
*  These functions will make use of a MsaParaGPopList, which in
*  turn points to a list of ParaG's.  Each ParaG describes a single
*  row, or sequence.  Each MsaParaGPopList describes all the sequences
*  that are being edited.
*----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
*  this structure has info for multiple sequence alignment and editing.
*---------------------------------------------------------------------------*/
typedef struct DDE_info {
  MsaParaGPopListPtr  pPopList;      /* the paragraphs as they're edited */
  Boolean*            pVisible;      /* whether each original row is visible */
  Int4*               pRowOrder;     /* order original (incl invisible) rows are displayed */
  Int4*               pRowOrderLUT;  /* look-up-table: on-screen -> original rows */
  Int4                TotalNumRows;  /* row count -- all rows, visible and invisible */
} DDE_Info, PNTR DDE_InfoPtr;

/*----------------------------------------------------------------------------
*  this structure has info for keeping a history of edit changes.
*---------------------------------------------------------------------------*/
#define DDE_STACK_SIZE  300          /* stack size -- arbitrary */
typedef struct DDE_stack {
  DDE_InfoPtr*  pArray;              /* array of DDE_InfoPtr's */
  DDE_InfoPtr   pOrig;               /* pointer to original structure */
  DDE_InfoPtr   pEdit;               /* pointer to structure being edited */
  Int4          NumInStack;          /* number of items in the stack */
  Int4          NumFromStart;        /* number of items from start to StackIndex */
  Int4          StackIndex;          /* next available slot on stack */
  Int4          StackMin;            /* can back up until here */
  Int4          StackMax;            /* can advance until here */
  Int4          FromRow;             /* row that's moving */
  Int4          SaveRow;             /* last drawn underline */
  Int4          FromCol;             /* for calculating num chars shifting left/right */
  Int4          SaveCol;             /* for last drawn dotted box */
  Int4          BlockIndex;          /* record of block that's being adjusted */
  Int4          LeftBoundary;        /* record of whether Left or Right boundary shift */
  Int4          LaunchBlock;         /* record of block editor was launched on */
  Boolean       IsUnAligned;         /* record of whether block editor was launched on is aligned */
  Int4          NumBlocks;           /* num blocks at last save */
  Boolean       SomethingToSave;     /* whether there are edits to save */
} DDE_Stack, PNTR DDE_StackPtr;

/*=====================================================================
*  these are the public member functions of DDE_Info.
*======================================================================*/
NLM_EXTERN DDE_StackPtr DDE_NewStack(MsaParaGPopListPtr pPopList);
NLM_EXTERN DDE_StackPtr DDE_FreeStack(DDE_StackPtr pStack);
NLM_EXTERN Boolean DDE_RestoreRowOrder(DDE_StackPtr pStack, Boolean Save);
NLM_EXTERN Boolean DDE_HideRow(DDE_StackPtr pStack, Int4 Row, Boolean Save);
NLM_EXTERN Boolean DDE_HideAllRows(DDE_StackPtr pStack, Boolean Save);
NLM_EXTERN Boolean DDE_HideNewRow(DDE_StackPtr pStack, Int4 Row, Boolean Save);
NLM_EXTERN Boolean DDE_ShowRow(DDE_StackPtr pStack, Int4 Row, Boolean Save);
NLM_EXTERN Boolean DDE_ShowAllRows(DDE_StackPtr pStack, Boolean Save);
NLM_EXTERN Boolean DDE_ShowNewRow(DDE_StackPtr pStack, Int4 Row, Boolean Save);
NLM_EXTERN Boolean DDE_MoveRow(DDE_StackPtr pStack, Int4 From, Int4 To, Boolean Save);
NLM_EXTERN Boolean DDE_ShiftRow(DDE_StackPtr pStack, Int4 Row, Int4 NumChars, Boolean Save,
                                Boolean ShiftBack);
NLM_EXTERN Boolean DDE_InsertGap(DDE_StackPtr pStack, Int4 Row, Int4 Pos, Boolean Save);
NLM_EXTERN Boolean DDE_RemoveGap(DDE_StackPtr pStack, Int4 Row, Int4 Pos, Boolean Save);
NLM_EXTERN Boolean DDE_ShiftLeftBoundary(DDE_StackPtr pStack, Int4 BlockIndex, Int4 NumChars, Boolean Save);
NLM_EXTERN Boolean DDE_ShiftRightBoundary(DDE_StackPtr pStack, Int4 BlockIndex, Int4 NumChars, Boolean Save);
NLM_EXTERN void DDE_ShiftBlock(DDE_StackPtr pStack, Int4 BlockIndex, Int4 NumChars, Boolean Save);
NLM_EXTERN void DDE_CreateBlock(DDE_StackPtr pStack, Int4 Left, Int4 Right, Boolean Save);
NLM_EXTERN Int4    DDE_DeleteBlock(DDE_StackPtr pStack, Int4 BlockIndex, Boolean Save);
NLM_EXTERN Boolean DDE_Select(DDE_StackPtr pStack, Int4 Row, Int4 Left, Int4 Right, Boolean Save);
NLM_EXTERN Boolean DDE_DeSelect(DDE_StackPtr pStack, Int4 Row, Int4 Left, Int4 Right, Boolean Save);
NLM_EXTERN Boolean DDE_SelectCol(DDE_StackPtr pStack, Int4 ColStart, Int4 ColStop, Boolean Save);
NLM_EXTERN Boolean DDE_DeSelectCol(DDE_StackPtr pStack, Int4 ColStart, Int4 ColStop, Boolean Save);
NLM_EXTERN Boolean DDE_Add(DDE_StackPtr pStack);
NLM_EXTERN Boolean DDE_Prev(DDE_StackPtr pStack);
NLM_EXTERN Boolean DDE_Next(DDE_StackPtr pStack);
NLM_EXTERN Boolean DDE_AtStartOfStack(DDE_StackPtr pStack);
NLM_EXTERN Boolean DDE_AtEndOfStack(DDE_StackPtr pStack);
NLM_EXTERN void DDE_GetOriginal(DDE_StackPtr pStack, Boolean Save);
NLM_EXTERN Int4 DDE_GetIndexOfMaster(DDE_StackPtr pStack);
NLM_EXTERN Int4 DDE_GetAlignStart(DDE_InfoPtr pEditInfo, Int4 BlockIndex);
NLM_EXTERN Int4 DDE_GetAlignStart2(MsaParaGPopListPtr pPopList, Int4 BlockIndex);
NLM_EXTERN Int4 DDE_GetAlignStop(DDE_InfoPtr pEditInfo, Int4 BlockIndex);
NLM_EXTERN Int4 DDE_GetAlignStop2(MsaParaGPopListPtr pPopList, Int4 BlockIndex);
NLM_EXTERN Int4 DDE_GetBlockWidth(DDE_InfoPtr pEditInfo, Int4 BlockIndex);
NLM_EXTERN Int4 DDE_GetNumBlocks(DDE_InfoPtr pEditInfo);
NLM_EXTERN Int4 DDE_GetNumBlocks2(MsaParaGPopListPtr pPopList);
NLM_EXTERN Boolean DDE_IsColValid(MsaParaGPopListPtr pPopList, Int4 Col,
                                  Int4 PNTR pBlockIndex, Boolean PNTR pUnAligned,
                                  Int4 PNTR pOffset, Int4 PNTR pWidth);
NLM_EXTERN Int4    DDE_GetNumSegmentsInBlock(DDE_InfoPtr pEditInfo, Int4 BlockIndex);
NLM_EXTERN Boolean DDE_CreateArraysForDenseSeg(DDE_InfoPtr pEditInfo, Int4 BlockIndex,
                                               Int4 PNTR pStarts, Int4 PNTR pLens);
NLM_EXTERN Int4    DDE_GetFirstDisplayCoord(MsaParaGPopListPtr pPopList);
NLM_EXTERN Boolean DDE_IsLeftAlignedGapInRows(DDE_InfoPtr pEditInfo);
NLM_EXTERN Boolean DDE_IsRightAlignedGapInRows(DDE_InfoPtr pEditInfo);
NLM_EXTERN void    DDE_RemoveAlignedGapsFromEnds(DDE_InfoPtr pEditInfo);
NLM_EXTERN void    DDE_RemoveAlignedGapsFromEndOfRow(DDE_StackPtr pStack, Int4 Row, Boolean RightSide);
NLM_EXTERN Boolean DDE_LeftJustify(DDE_StackPtr pStack, Boolean Save);
NLM_EXTERN Boolean DDE_RightJustify(DDE_StackPtr pStack, Boolean Save);
NLM_EXTERN Boolean DDE_CenterJustify(DDE_StackPtr pStack, Boolean Save);
NLM_EXTERN Boolean DDE_FirstColumnIsAligned(DDE_InfoPtr pEditInfo);
NLM_EXTERN Boolean DDE_LastColumnIsAligned(DDE_InfoPtr pEditInfo);
NLM_EXTERN ValNodePtr  DDE_GetTxtListPtr(DDE_InfoPtr pEditInfo, Int4 Row);
NLM_EXTERN ValNodePtr  DDE_GetMsaTxtNode(ValNodePtr head, Int4 DispCoord, Int4 PNTR pOffset);
NLM_EXTERN ValNodePtr  DDE_GetMsaTxtNode2(ValNodePtr pg_head, Int4 DispCoord, Int4 PNTR pOffset);
NLM_EXTERN ValNodePtr  DDE_GetMsaTxtNodeGivenBioseqCoord(MsaParaGPopListPtr pPopList,
                                                         Int4 BioseqCoord, Int4 Row);
NLM_EXTERN Int4 DDE_GetStart(MsaParaGPopListPtr pPopList, Int4 BlockIndex, Int4 Row);
NLM_EXTERN Int4 DDE_GetLen(MsaParaGPopListPtr pPopList, Int4 BlockIndex);

/*=====================================================================
*  here are some helper functions
*======================================================================*/
NLM_EXTERN DDE_InfoPtr  DDE_New(MsaParaGPopListPtr pPopList, Int4 TotalNumRows);
NLM_EXTERN DDE_InfoPtr  DDE_Free(DDE_InfoPtr pEditInfo, Int4 TotalNumRows);
NLM_EXTERN DDE_InfoPtr  DDE_Copy(DDE_InfoPtr pEditInfo, Int4 TotalNumRows);
NLM_EXTERN MsaParaGPopListPtr DDE_PopListNew(MsaParaGPopListPtr pPopList, Int4 TotalNumRows);
NLM_EXTERN MsaParaGPopListPtr DDE_PopListFree(MsaParaGPopListPtr pPopList, Int4 TotalNumRows);
NLM_EXTERN ParaGPtr    DDE_ParaGNew(ParaGPtr pParaG);
NLM_EXTERN ParaGPtr    DDE_ParaGFree(ParaGPtr pParaG);
NLM_EXTERN Int4        DDE_GetNumVisibleRows(DDE_InfoPtr pEditInfo);
NLM_EXTERN Int4        DDE_GetDisplayRow(DDE_InfoPtr pEditInfo, Int4 Row);
NLM_EXTERN Int4        DDE_GetInsertRow(DDE_InfoPtr pEditInfo, Int4 Row);
NLM_EXTERN Boolean     DDE_IsBefore(DDE_InfoPtr pEditInfo, Int4 Row1, Int4 Row2);
NLM_EXTERN ParaGPtr    DDE_GetParaGPtr(DDE_InfoPtr pEditInfo, Int4 Row);
NLM_EXTERN ParaGPtr    DDE_GetParaGPtr2(MsaParaGPopListPtr pPopList, Int4 Row);
NLM_EXTERN ValNodePtr  DDE_GetTxtListPtr2(MsaParaGPopListPtr pPopList, Int4 Row);
NLM_EXTERN void        DDE_SetTxtListPtr(DDE_InfoPtr pEditInfo, Int4 Row, ValNodePtr vnp);
NLM_EXTERN ValNodePtr  DDE_AddMsaTxtNode(ValNodePtr ptxtList, Int4 from, Int4 to,
                            Boolean IsGap, Boolean IsUnAligned, Boolean Before);
NLM_EXTERN ValNodePtr  DDE_AddRulerDescrNode(ValNodePtr pRulerDescr, Int4 DispStart,
                            Int4 DispStop, Int4 AlignStart, Boolean IsUnAligned, Boolean Before);
NLM_EXTERN void        DDE_IncDisplayCoords(ValNodePtr ptxtList);
NLM_EXTERN void        DDE_DecDisplayCoords(ValNodePtr ptxtList);
NLM_EXTERN ValNodePtr  DDE_AddAGap(DDE_InfoPtr pEditInfo, Int4 Row,
                            ValNodePtr ptxtList, Boolean Before, Boolean ForceUnAligned);
NLM_EXTERN ValNodePtr  DDE_AddGapAndSplitNode(ValNodePtr pInsertNode, Int4 Offset, Int4 Pos);
NLM_EXTERN ValNodePtr  DDE_RemoveAGap(DDE_InfoPtr pEditInfo, Int4 Row, ValNodePtr pRemoveNode,
                                      Boolean* pNodeDeleted);
NLM_EXTERN Int4        DDE_GetGapIndex(ValNodePtr ptxtList, ValNodePtr pMidttxtList,
                            Boolean Before);
NLM_EXTERN ValNodePtr  DDE_GetPrevVNP(ValNodePtr head, ValNodePtr curr);
NLM_EXTERN Boolean     DDE_ShiftRowLeft1(DDE_InfoPtr pEditInfo, Int4 Row, ValNodePtr ptxtList,
                                         Boolean OkToAddGaps);
NLM_EXTERN Boolean     DDE_ShiftRowRight1(DDE_InfoPtr pEditInfo, Int4 Row, ValNodePtr ptxtList,
                                          ValNodePtr prev_vnp, Boolean InsertLeftGap);
NLM_EXTERN void        DDE_AddGapToStartOfAllRows(DDE_InfoPtr pEditInfo, Boolean ReMakeRuler);
NLM_EXTERN void        DDE_AddGapToEndOfAllRows(DDE_InfoPtr pEditInfo, Boolean ReMakeRuler);
NLM_EXTERN Boolean     DDE_RemoveGapFromStartOfAllRows(DDE_InfoPtr pEditInfo, Boolean ReMakeRuler);
NLM_EXTERN Boolean     DDE_RemoveGapFromEndOfAllRows(DDE_InfoPtr pEditInfo, Boolean ReMakeRuler);
NLM_EXTERN Boolean     DDE_CleanEnds(DDE_InfoPtr);
NLM_EXTERN Boolean     DDE_IsLeftAlignedGap(ValNodePtr ptxtList);
NLM_EXTERN Boolean     DDE_IsLeftAlignedGapList(ValNodePtr ptxtList, Boolean DeleteIt);
NLM_EXTERN Boolean     DDE_IsRightAlignedGap(ValNodePtr ptxtList);
NLM_EXTERN Boolean     DDE_IsTerminalRightAlignedGap(ValNodePtr ptxtList);
NLM_EXTERN Boolean     DDE_IsRightAlignedGapList(ValNodePtr PNTR pptxtList, Boolean DeleteIt);
NLM_EXTERN Boolean     DDE_LeftMerge(ValNodePtr ptxtList);
NLM_EXTERN Boolean     DDE_LeftAddNode(ValNodePtr ptxtList, Boolean PNTR pNodeDeletedToo);
NLM_EXTERN void        DDE_LeftMergeAndAddNodeList(ValNodePtr ptxtList, Boolean AfterGap);
NLM_EXTERN Boolean     DDE_RightMerge(ValNodePtr PNTR pptxtList, Boolean PNTR pHeadChanged);
NLM_EXTERN Boolean     DDE_RightAddNode(ValNodePtr PNTR pptxtList, Boolean PNTR pHeadChanged);
NLM_EXTERN Boolean     DDE_RightMergeAndAddNodeList(ValNodePtr PNTR pptxtList);
NLM_EXTERN void        DDE_ShiftLeftList(DDE_InfoPtr pEditInfo, Int4 Row, ValNodePtr ptxtList,
                                         Boolean AfterGap, Boolean LastCharIsUnAligned);
NLM_EXTERN Boolean     DDE_ShiftRightList(ValNodePtr PNTR pptxtList, ValNodePtr StopNode,
                                          Boolean FirstCharIsUnAligned, Boolean InsertLeftGap,
                                          Boolean OkToShrinkLastNode);
NLM_EXTERN ValNodePtr  DDE_GetLastVNP(ValNodePtr ptxtList);
NLM_EXTERN Int4        DDE_GetNumResidues(MsaParaGPopListPtr pPopList, Int4 Row);
NLM_EXTERN Boolean     DDE_IsStartOfAlignment(ValNodePtr ptxtList);
NLM_EXTERN Boolean     DDE_IsEndOfAlignment(ValNodePtr ptxtList);
NLM_EXTERN Boolean     DDE_ShiftLeftBoundaryLeft1(DDE_InfoPtr pEditInfo, Int4 BlockIndex);
NLM_EXTERN Boolean     DDE_ShiftLeftBoundaryRight1(DDE_InfoPtr pEditInfo, Int4 BlockIndex);
NLM_EXTERN Boolean     DDE_ShiftRightBoundaryLeft1(DDE_InfoPtr pEditInfo, Int4 BlockIndex);
NLM_EXTERN Boolean     DDE_ShiftRightBoundaryRight1(DDE_InfoPtr pEditInfo, Int4 BlockIndex);
NLM_EXTERN ValNodePtr  DDE_ReMakeRuler(MsaParaGPopListPtr pPopList, Boolean Replace, Int4 AlignStart);
NLM_EXTERN ValNodePtr  DDE_ReMakeRulerForRow(MsaParaGPopListPtr pPopList, Int4 Row, Int4 AlignStart);
NLM_EXTERN Boolean     DDE_AreIdenticalRulers(ValNodePtr pRuler1, ValNodePtr pRuler2);
NLM_EXTERN Boolean     DDE_AreIdenticalRulerDescrs(DDVRulerDescrPtr p1, DDVRulerDescrPtr p2);
NLM_EXTERN Boolean     DDE_AreSimilarRulers(ValNodePtr pRuler1, ValNodePtr pRuler2,
                                            Int4* pDispCoord1,  Int4* pDispCoord2);
NLM_EXTERN Boolean     DDE_AreSimilarRulerDescrs(DDVRulerDescrPtr p1, DDVRulerDescrPtr p2);
NLM_EXTERN Boolean     DDE_MergeNodes(ValNodePtr ptxtList);
NLM_EXTERN void        DDE_MergeNodesLists(DDE_InfoPtr pEditInfo);
NLM_EXTERN Int4        DDE_GetFirstAlignIndex(MsaParaGPopListPtr pPopList);
NLM_EXTERN void        DDE_Verify(DDE_InfoPtr pEditInfo);
NLM_EXTERN ValNodePtr  DDE_SplitNode(ValNodePtr ptxtList, Int4 Offset);
NLM_EXTERN void        DDE_SetTextStyle(MsaTxtDispPtr msap);
NLM_EXTERN Boolean     DDE_GetColStatusForRow(DDE_InfoPtr pEditInfo, Int4 Row, Int4 Col,
                                              Boolean PNTR pUnAligned, Boolean PNTR pGap);
NLM_EXTERN Boolean     DDE_GetGapStatusOfRows(DDE_InfoPtr pEditInfo, Boolean PNTR pGapArray,
                                              Int4 Col);
NLM_EXTERN Boolean     DDE_AreArraysSame(Boolean PNTR pArray1, Boolean PNTR pArray2, Int4 Size);
NLM_EXTERN Boolean     DDE_GetAlignIndices(DDE_InfoPtr pEditInfo, Int4 PNTR pIndices, Int4 Col);
NLM_EXTERN Boolean     DDE_AddIndicesToArray(Int4 PNTR pArray, Int4 PNTR pIndices,
                                             Int4 Size, Int4 ArrayIndex);
NLM_EXTERN Int4        DDE_GetNumLeadingUnAlignedGaps(DDE_InfoPtr pEditInfo, Int4 Row);
NLM_EXTERN Int4        DDE_GetNumTrailingUnAlignedGaps(DDE_InfoPtr pEditInfo, Int4 Row);

/*----------------------------------------------------------------------------
*  This is the end of my code -- Dave Hurwitz
*----------------------------------------------------------------------------*/

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

Function: SAM_ReplaceGI()

Purpose: Tries to replace all gi's in a seqalign with the best accession ID's
  
Parameters: salp, the seqalign to be worked over.

Returns: This function only works on a non-indexed list of seqaligns

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

NLM_EXTERN void SAM_ReplaceGI(SeqAlign *salp);

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

Function: SAM_ExtractSips()

Purpose: Return a ValNode list containing a SeqId for each Bioseq
         contained in a SeqEntry.
  
Parameters: sep, pointer to the SeqEntry to explore

Returns: ValNode list of pointers to SeqId's.  Do NOT deallocate, these are
         not duplicates!

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

NLM_EXTERN ValNode * SAM_ExtractSips(SeqEntry *sep);


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

Function: SAM_MakeViewerFree()

Purpose: Set an object to use OM_OPT_FREE_IF_NO_VIEW flag.
  
Parameters: data, pointer to the object to be flagged.

Returns: 1 if OK, 0 otherwise.

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

NLM_EXTERN Int4 SAM_MakeViewerFree (void *data);


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

Function: SAM_MakeTemp()

Purpose: Make an object temporary loaded.
  
Parameters: data, pointer to the object to be flagged.

Returns: 1 if OK, 0 otherwise.

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

NLM_EXTERN Int4 SAM_MakeTemp (void *data);


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

Function: SAM_ValNodePut()

Purpose: Put a ValNode in a list of ValNodes by cardinal order.
  
Parameters: ppvnHead, pointer to head of ValNode list
            Num, the number of the ValNode to insert before.  begins with 0.
            pvnInsert, the valnode to insert

Returns: 1 if OK, 0 otherwise.

Notes: Hangs on loops that don't include the head.

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

NLM_EXTERN Int4 SAM_ValNodePut
(ValNode **ppvnHead, ValNode *pvnInsert, Int4 Num);


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

Function: SAM_ValNodeExtract()

Purpose: Takes a ValNode out of a list of ValNodes by cardinal order.
  
Parameters: ppvnHead, pointer to head of ValNode list
            Num, the number of the ValNode to extract (the 2nd, 3rd, etc.)

Returns: The extracted ValNode. NULL otherwise.

Notes: Hangs on loops that don't include the head.

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

NLM_EXTERN ValNode * SAM_ValNodeExtract(ValNode **ppvnHead, Int4 Num);

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

Function: SAM_ValNodeByPosition()

Purpose: Return pointer to ValNode in a list of ValNodes by cardinal order.
  
Parameters: ppvnHead, pointer to head of ValNode list
            Num, the number of the ValNode to get (the 2nd, 3rd, etc.).
                 starts at 0.

Returns: The ValNode at position NUM. NULL otherwise.

Notes: Hangs on loops that don't include the head.

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

NLM_EXTERN ValNode * SAM_ValNodeByPosition(ValNode **ppvnHead, Int4 Num);


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

Function: SAM_SeqAlignExtract()

Purpose: Takes a SeqAlign out of a list of SeqAligns.  The extracted SeqAlign
         is the first one pointer matches the passed SeqAlign pointer.
  
Parameters: psalpHead, pointer to head of SeqAlign list
            salpCheck, points to the SeqAlign to be extracted

Returns: The extracted SeqAlign. NULL otherwise

Notes: Hangs on loops that don't include the head.

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

NLM_EXTERN SeqAlign * SAM_SeqAlignExtract
(SeqAlign **psalpHead, SeqAlign *salpCheck);

/*****************************************************************************
*
*   Adds a SeqAlign newnode to the end of a SeqAlign chain started by head.
*   
*   If the head is NULL, makes the newnode the head.
*   Returns the head of the SeqAlign chain, otherwise returns NULL on error.
*
*****************************************************************************/

NLM_EXTERN SeqAlign * SAM_Add2SeqAlign(SeqAlign ** head, SeqAlign *newnode);

/*****************************************************************************
*
*   Frees a list of SeqId's.  Returns the remaining SeqId * if fails,
*   Otherwise NULL. 
*
*****************************************************************************/

NLM_EXTERN SeqId * SAM_FreeSeqIdSet(SeqId *sip);

/*****************************************************************************
*
*   Retrieves SeqIds from a set of seqlocs, duplicates the first SeqId, then
*   appends it to a list of SeqId's, which is returned.  
*
*   Returns NULL if the seqlocs are of any type other that SEQLOC_INT or the
*   SeqLoc doesn't contain a SeqId.
*
*****************************************************************************/

NLM_EXTERN SeqId * SAM_SeqIdFromSeqLoc(SeqLoc *slp, Int4 *NumSeqs);


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

Function: SAM_NewDenseSeg()

Purpose: Constructs a new DenseSeg, all arrays initialized to sizes based on
          NumSeqs and NumSegs

Parameters: NumSeqs, the number of sequences
            NumSegs, the number of Segments
            Strands, if TRUE, initialize the strands array.

Returns: The new DenseSeg. NULL otherwise.

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

NLM_EXTERN DenseSeg *SAM_NewDenseSeg
(Int4 NumSeqs, Int4 NumSegs, Boolean Strands);


/*****************************************************************************
*
*   Constructs a new SeqAlign of type type and segment type segtype.  Add segs
*   to the seg pointer and sets the dimension of the SeqAlign to dim.
*
*   Returns NULL on error
*
*****************************************************************************/

NLM_EXTERN SeqAlign *SAM_NewSeqAlign
(Uint1 type, Uint1 segtype, Pointer segs, Int2 dim);


/*****************************************************************************
*
*   Checks to see how a postion is inside or is in front of or in back of a
*   range.
*   If it is inside, return SAM_TOTALLAP
*   If it doesn't, return SAM_NOLAP & SAM_NOLAPFRONT if in front
*   If it doesn't and is in back return SAM_NOLAP & SAM_NOLAPBACK
*
*****************************************************************************/

NLM_EXTERN Int4 SAM_InRange(Int4 Position, Int4 From, Int4 To);

/*****************************************************************************
*
*   Checks to see if Range1 overlaps Range2.
*   If it does completely, return SAM_TOTALLAP
*   If it doesn't, return SAM_NOLAP & SAM_NOLAPFRONT if in front
*   If it doesn't and is in back return SAM_NOLAP & SAM_NOLAPBACK
*   If pRange1 overlaps the front of pRange2, return SAM_FRONTLAP
*   If pRange1 overlaps the rear of pRange2, return SAM_BACKLAP
*
*****************************************************************************/

NLM_EXTERN Int4 SAM_RangeOverlap(Int4 From1, Int4 To1, Int4 From2, Int4 To2);

/*****************************************************************************
*
*   Lexically compare two SeqId's.  Checks ALL sips on both chains.
*   Returns -1 if sip1 <  sip2
*            0 if sip1 == sip2
*            1 if sip1 >  sip2
*
*****************************************************************************/

NLM_EXTERN Int4 SAM_LexicalComp(SeqId *sip1, SeqId *sip2);

/*****************************************************************************
*
*   Orders two SeqId's for binary searches, etc.  DOES check the full
*   ValNode lists.  The ordering is arbitrary but consistent.
*   Returns -1 if sip1 <  sip2
*            0 if sip1 == sip2
*            1 if sip1 >  sip2
*
*****************************************************************************/

NLM_EXTERN Int4 SAM_OrderSeqIDChain (SeqId *sip1, SeqId *sip2);

/*****************************************************************************
*
*   Orders two SeqId's for binary searches, etc. Does NOT check the full
*   ValNode lists.  The ordering is arbitrary but consistent.
*   Returns -1 if sip1 <  sip2
*            0 if sip1 == sip2
*            1 if sip1 >  sip2
*
*****************************************************************************/

NLM_EXTERN Int4 SAM_OrderSeqID(SeqId *sip1, SeqId *sip2);

/*****************************************************************************
*
*   Orders two SeqId's for binary searches, etc.  If any id's in chains are
*   equivalent, returns 0.
*   Returns -1 if sip1 <  sip2
*            0 if sip1 == sip2
*            1 if sip1 >  sip2
*
*****************************************************************************/

NLM_EXTERN Boolean SAM_SeqIdCompareAll(SeqId *sip1, SeqId *sip2);

/*****************************************************************************
*
*   Compare two AlignId to make sure all valnodes compare exactly
*
*****************************************************************************/

NLM_EXTERN Boolean SAM_AlignIdCompare(AlignId *saip1, AlignId *saip2);


/*****************************************************************************
*
*     Looks for single AlignId, "a" in chain of AlignIds, "b"
*
*****************************************************************************/

NLM_EXTERN Boolean SAM_AlignIdIn (AlignId *a, AlignId *b);


/*****************************************************************************
*
*   	Compares a to b and returns
*
*   SIC_DIFF   = different types, could not be compared
*   SIC_NO     = types could be compared, and ids are different
*   SIC_YES    = types could be compared, and ids are the same
*
*****************************************************************************/

NLM_EXTERN Uint1 SAM_AlignIdComp (AlignId *a, AlignId *b);


/*******************************************************
*
*   duplicate a list of AlignId *
*
*******************************************************/

NLM_EXTERN AlignId * SAM_AlignIdDupList (AlignId *id_list);


/*******************************************************
*
*   Duplicates one AlignId
*
*******************************************************/

NLM_EXTERN AlignId * SAM_AlignIdDup (AlignId *oldid);


#ifdef __cplusplus
}
#endif

#undef NLM_EXTERN
#ifdef NLM_EXPORT
#define NLM_EXTERN NLM_EXPORT
#else
#define NLM_EXTERN
#endif

#endif /* SAMUTIL_H */