/*****************************************************************************
#   Copyright (C) 1994-2008 by David Gordon.
#   All rights reserved.                           
#                                                                           
#   This software is part of a beta-test version of the Consed/Autofinish
#   package.  It should not be redistributed or
#   used for any commercial purpose, including commercially funded
#   sequencing, without written permission from the author and the
#   University of Washington.
#   
#   This software is provided ``AS IS'' and any express or implied
#   warranties, including, but not limited to, the implied warranties of
#   merchantability and fitness for a particular purpose, are disclaimed.
#   In no event shall the authors or the University of Washington be
#   liable for any direct, indirect, incidental, special, exemplary, or
#   consequential damages (including, but not limited to, procurement of
#   substitute goods or services; loss of use, data, or profits; or
#   business interruption) however caused and on any theory of liability,
#   whether in contract, strict liability, or tort (including negligence
#   or otherwise) arising in any way out of the use of this software, even
#   if advised of the possibility of such damage.
#
#   Building Consed from source is error prone and not simple which is
#   why I provide executables.  Due to time limitations I cannot
#   provide any assistance in building Consed.  Even if you do not
#   modify the source, you may introduce errors due to using a
#   different version of the compiler, a different version of motif,
#   different versions of other libraries than I used, etc.  For this
#   reason, if you discover Consed bugs, I can only offer help with
#   those bugs if you first reproduce those bugs with an executable
#   provided by me--not an executable you have built.
# 
#   Modifying Consed is also difficult.  Although Consed is modular,
#   some modules are used by many other modules.  Thus making a change
#   in one place can have unforeseen effects on many other features.
#   It may takes months for you to notice these other side-effects
#   which may not seen connected at all.  It is not feasable for me to
#   provide help with modifying Consed sources because of the
#   potentially huge amount of time involved.
#
#*****************************************************************************/
#ifndef assemblyView_included
#define assemblyView_included

#include    "rwcstring.h"
#include    <Xm/Xm.h>
#include    "rwtptrorderedvector.h"
#include    "rwtvalorderedvector.h"
#include    "guiapp.h"
#include    "fwdRevPairTriangle.h"
#include    "fwdRevPairLine.h"
#include    "arrayOfFwdRevPairTriangles.h"
#include    "arrayOfFwdRevPairSquares.h"
#include    "arrayOfFwdRevPairLines.h"
#include    "rwt2dptrvector.h"
#include    "min.h"
#include    "max.h"
#include    "seqMatch.h"
#include    "consedParameters.h"


class GuiColorText;
class LocatedFragment;
class matchWithinAssembly;
class Contig;
class Assembly;
class assemblyView;
class clScaffold;
class fwdRevPair;
class guiMultiContigNavigator;
class subcloneTTemplate;
class gotoItem;
class assemblyViewRemoveReads;
class seqMatch;
class guiChoiceOfSeqMatches;
class guiReorderContigs;
class guiReorientContigs;
class guiAssemblyViewIncludeContigs;
class restrictionFragment;
class guiDisplayDigest;


typedef RWTPtrOrderedVector<seqMatch> arrayOfSeqMatches;
class tag;
typedef RWTPtrOrderedVector<tag> arrayOfTags;

typedef RWT2DPtrVector<arrayOfTags> scaffoldLineTagBar;


class assemblyView {
public:

   enum { nZOOM_IN = 0x1, nZOOM_OUT = 0x2, nZOOM_ORIGINAL = 0x3 };

   enum eScaleTickType { eBigTick = 0x1, eMediumSizedTick = 0x2,
                         eLittleTick = 0x3 };

   assemblyView();

   ~assemblyView();

   void createWindow( Assembly* pAssembly );


   void drawScaffolds();
   void drawScaffold( const int nScaffold );

   void drawContigBar( const int nContig, const int nScaffold );
   void drawScaleForEachContigInScaffold( const int nScaffold );
   void drawContigLabels( const int nScaffold );

   void drawScaleTick( const int nScaffold,
                       const int nScaffoldPos,
                       const int nUnpaddedBase,
                       int& nRightmostUsedPixelForNumber );

   void drawEverything( const bool bCalculatePositions,
                        const bool bFirstErase );

   void drawFwdRevPairDepth();

   void drawFwdRevPairDepthForOneContig(
                         const int nScaffold,
                         const int nContig );

   int nGetNumberOfBasesPerFwdRevPairPoint();

   int nGetPixelYFromNumberOfFwdRevPairs( const int nNumberOfFwdRevPairs,
                                          const int nZeroBasedContigOrderFromTop );

   void drawReadDepth();
   void drawReadDepthForOneContig( const int nScaffold,
                                   const int nContig );

   void drawMultipleDiscrepancies();

   void drawMultipleDiscrepanciesForOneContig( 
                          const int nScaffold,
                          const int nContig );

   void filteredBadFwdRevPairs();

   fwdRevPair2* pBadFwdRevPairInSameScaffold(
                      LocatedFragment* pLocFrag1,
                      LocatedFragment* pLocFrag2,
                      const int nScaffold,
                      const char cProblem );

   fwdRevPair2* pBadFwdRevPairInDifferentScaffolds(
                       LocatedFragment* pBestForwardLocFrag,
                       LocatedFragment* pBestReverseLocFrag,
                       const int nScaffoldOfBestForwardLocFrag,
                       const int nScaffoldOfBestReverseLocFrag,
                       const char cProblem );

   int nGetHeightFromSize( const int nSizeOfSubclone );
   int nGetHeightFromRepeatSeparation( const int nSeparationInScaffoldPos );

   double dCalculateInitialZoomFactor();

   void userZoomed( const int nZoomHow );
   void zoomVertically( const int nZoomHow );
   void zoomHorizontally( const int nZoomHow );

   void userResizedWindow();

   int nGetAscentOfScaffold();

   long lCalculateWidthOfScaleTicks();

   int nGetPixelXFromScaffoldPos( const int nScaffold,
                                  const int nScaffoldPos );

   int nGetPixelXFromScreenScaffoldPos( const int nScreenScaffoldPos );
   int nGetPixelXFromContigBase(  const int nScaffold,
                                  Contig* pContig,
                                  const int nUnpadded );

   int nGetAssemblyViewWindowWidth();
   int nGetAssemblyViewWindowHeight();

   int nGetScaffoldForContig( Contig* pContigToFind );
   int nGetFirstScaffoldOnScaffoldRow( const int nScaffoldRow );

   void drawFwdRevPairs( const bool bCalculatePositions );
   void calculateWhereFwdRevPairsAre();

   fwdRevPair2* pCalculateWhereSingleFwdRevPairIs(
                            LocatedFragment* pLeftLocFrag,
                            LocatedFragment* pRightLocFrag,
                            const bool bIsConsistent,
                            const char cProblem );


   fwdRevPair2* pConsistentFwdRevPairWithinSingleContig(
                                      LocatedFragment* pBestForwardLocFrag,
                                      LocatedFragment* pBestReverseLocFrag,
                                      const int nScaffold );

   fwdRevPair2* pConsistentGapSpanningPair(
                              LocatedFragment* pBestForwardLocFrag,
                              LocatedFragment* pBestReverseLocFrag,
                              const int nScaffold );

   fwdRevPair2* pConsistentPairBetweenDifferentScaffolds(
                              LocatedFragment* pBestForwardLocFrag,
                              LocatedFragment* pBestReverseLocFrag,
                              const int nScaffold1,
                              const int nScaffold2 );

   void adjustScrollBarsWhenZoom( const bool bMoveHorizontalSlider,
                                  const bool bMoveVerticalSlider );

   void adjustHorizontalScrollBarWhenZoom( const bool bMoveSlider );
   void adjustVerticalScrollBarWhenZoom( const bool bMoveSlider );

   void horizontalScrollBarMoved( const int nNewScrollBarPosition );
   void programScrollVertically( const int nNewTopEdgePixelY );

   void setHorizontalScrollBar();

   void verticalScrollBarMoved( const int nNewScrollBarPosition );

   void setVerticalScrollBar();

   void programMovedHorizontalScrollBar( const int nNewScrollBarPosition );

   void pointerMoved( const int nPixelX, const int nPixelY );

   void prepareToRecordObjectsDrawn();

   void afterRecordingObjectsDrawn();

   void unhighlightCurrentObjects();
   void unhighlightCurrentFwdRevPairs();
   void unhighlightCurrentSeqMatches();
   void highlightNewObject( fwdRevPair2* pPairToHighlight );
   void highlightSeqMatch( seqMatch* pSeqMatch );
   void unhighlightClickedObjects();

   void highlightClickedObjects();
   void highlightClickedFwdRevPairs();
   void highlightClickedSeqMatches();
   void drawClickedObjects( const bool bBlinkState );


   bool bIsPointerYOnAScaffoldRow( 
                                  const int nPixelY,
                                  int& nFirstScaffoldOnScaffoldRow );

   bool bIsPointerYOnAScaffoldRowOrItsTags( 
                                  const int nPixelY,
                                  int& nFirstScaffoldOnScaffoldRow );

   bool bIsPointerXOnAContig(
                             const int nFirstScaffoldOnScaffoldRow,
                             const int nPixelX,
                             Contig*& pContigOfPointer,
                             int& nUnpaddedOfPointer,
                             bool& bContigComplementedInScaffold );

   void displayContigLocation( const int nPixelX,
                               const int nPixelY,
                               RWCString& soMessage,
                               bool& bIsOnAContig,
                               Contig*& pContig,
                               int& nUnpadded );


   void displayReadDepth( RWCString& soMessage,
                          Contig* pContig,
                          const int nUnpadded );

   void displayFwdRevPairDepth( RWCString& soMessage,
                                Contig* pContig,
                                const int nUnpadded );

   void programHighlightsRead( LocatedFragment* pLocFrag );

   void displayMessageAtBottom( const RWCString& soMessage );
   void displayHighlightedObjects( RWCString& soMessage );
   void displayHighlightedRestrictionDigestCutSites( RWCString& soMessage );

   void checkIfOnATag( const int nPixelX,
                       const int nPixelY,
                       RWCString& soMessage );

   void checkIfOnATag2( const int nScaffoldRow,
                        const int nTagLine,
                        const int nTagCellIndex,
                        RWTPtrOrderedVector<tag>* pTagArray );

   bool bCheckIfOnATag( const int nPixelX,
                        const int nPixelY,
                        RWTPtrOrderedVector<tag>* pTagArray );

   void userClickedOrSomething(
                          XmDrawingAreaCallbackStruct* pDAC );

   void displayPopupBoxForClickedObjects();
   void displayPopupBoxForClickedFwdRevPairs();
   void displayPopupBoxForClickedSeqMatches();

   void makeGotoItemsForSubclone( fwdRevPair2* pPair );

   void raiseWindow();

   void showDocumentationForAssemblyView();

   void readFileOfTemplatesToNotShow(
                         const FileName& filTemplatesToNotShow );

   void readFileOfTemplatesToNotShowIfItExists();

   void markFwdRevPairsForThoseNotToShow();

   void userClickedButtonInNavigatorWindow();

   void parseCrossMatchOutput();

   void calculateSeqMatchPositions();

   void calculatePositionOfOneSeqMatch( seqMatch* pSeqMatch );

   void calculateBezierCoefficientsOfOneSeqMatch( seqMatch* pSeqMatch );

   void drawOneRepeatArc( seqMatch* pSeqMatch, 
                          const int nArc,
                          const bool bSavePositionsInGrid,
                          const bool bHighlight );

   void drawOneRegionBaseline( seqMatch* pSeqMatch,
                               const int nRegion,
                               const bool bHighlight );

   void drawOneRepeat( seqMatch* pSeqMatch,
                       const bool bSavePositionsInGrid,
                       const bool bHighlight );

   void drawRepeats2( const bool bSavePositionsInGrid );

   void drawRepeats( bool bFirstCalculatePositions );

   void createNewGridTable();

   void clearOldGridTable();

   void putLineSegmentIntoGrid( const int nX0,
                                const int nY0,
                                const int nX1,
                                const int nY1,
                                seqMatch* pSeqMatch );

   bool bIsOnScreen( const int nX, const int nY );

   bool bFastaFileMatchesAceFile( const FileName& filFastaFile );


   void userPushedContigArrangement( XEvent* pEvent );


   void userPushedReorientContigs();
   void userPushedReorderContigs();
   void userPushedFreezeContigOrder();
   void userPushedIncludeContigs();
   void userPushedWhatToShow( XEvent* pEvent );
   void userPushedGotoAlignedReadsWindow();
   void userPushedMouseButton3InDrawingArea( XButtonPressedEvent* pEvent );

   void userPushedWhichTagsToShow();
   void userPushedGotoTagInAlignedReadsWindow();
   void userPushedGotoFragmentInDigestWindow();
   void userPushedDigestCutSites();
   void userPushedHideOrShowTags();


   void arrangeScaffoldsOnScreen();

   bool bIsThisADesiredTagType( const RWCString& soTagType,
                                int& nLineWithinTagBar );

   int  nGetTagCellIndexFromContigBase( const int nScaffold,
                                        Contig* pContig,
                                        const int nUnpadded );

   void getConsPosRangeOfTagCell( const int nCellIndex,
                                  const int nScaffold,
                                  Contig* pContig,
                                  int& nConsPosLow,
                                  int& nConsPosHigh,
                                  bool& bProblems );

   void getTagCellRangeForTag( Contig* pContig,
                               const int nScaffold,
                               tag* pTag,
                               int& nTagCellStart,
                               int& nTagCellEnd,
                               bool& bNotOnScreen );

   void calculateTagLines();
 
   void drawTags();
   void drawTagsOnOneScaffoldRow( const int nScaffoldRow );



   void drawTagCell( const int nScaffoldRow,
                     const int nTagLine,
                     const int nCellIndex,
                     GuiColorText* pGuiColorText,
                     const bool bReverseGC );

   void highlightTags( const int nPixelX,
                       const int nPixelY );


   enum eHighlightType { eHIGHLIGHT_ON = 1, eHIGHLIGHT_OFF = 2 };

   void highlightTag( tag* pTag,
                      const eHighlightType nHighlight );


   void drawRestrictionDigestFragments();

   void drawRestrictionEnzymeFragment( restrictionFragment* pResFrag,
                                       const bool bHighlight );

   bool bIsFragmentDisplayed( restrictionFragment* pResFrag,
                              int& nScaffold,
                              int& nScaffoldPosLeft,
                              int& nScaffoldPosRight );

   void highlightRestrictionDigestFragments( 
            const int nCursorPixelX,
            const int nCursorPixelY );

   void setContigScaffolds( const RWTPtrOrderedVector<clScaffold>& aScaffolds );

   void drawCloneEnds();

   void drawCloneEndTag( tag* pCloneEndTag );

   void guiDrawCloneEndTag( const int nScaffold,
                            const int nScaffoldPos,
                            const bool bInsertToRight );

   void assignEnzymeLinesToFragments();

   void findContig();

private:
   // screen real estate for drawing:
// screen real estate
//     top of screen
//     region for consistent fwd/rev pairs
//     _______________________  ____________  _________ (contig lines) 
//      |     |     |     |      |    |    |   |    |    (scale ticks)
//     200         300          200       300            (scale numbers)
//             Contig3             Contig1      Contig2
//       (grey bar)
//     _______________________  ____________  _________ (contig lines)
//    (space for inconsistent fwd/rev pairs within the same scaffold )
//    space between scaffolds
//    region for consistent fwd/rev pairs
//    .
//    .
//    .

   // the grey bar (above) goes from nGetPixelYOfScaffoldBaseline to
   // nGetPixelYOfTopOfAreaForInconsistentFwdRevPairs



   inline int nGetPixelYLOfConsistentFwdRevPairBaseline() {
      return( nHeightOfAreaForFwdRevPairsInSameScaffold_ );
   }


   inline int nGetPixelYLOfScaffoldBaseline() {
      return( nGetPixelYLOfConsistentFwdRevPairBaseline() );
   }


   inline int nGetPixelYLOfScaleTickTop() {
      return( nGetPixelYLOfScaffoldBaseline() );
   }


   enum { nLittleScaleTickHeight = 3};

   inline int nGetPixelYLOfLittleScaleTickBottom() {
      return( nGetPixelYLOfScaleTickTop() + nLittleScaleTickHeight );
   }

   enum { nMediumSizedScaleTickHeight = 5 };

   inline int nGetPixelYLOfMediumSizedScaleTickBottom() {
      return( nGetPixelYLOfScaleTickTop() + nMediumSizedScaleTickHeight );
   }

   enum { nBigScaleTickHeight = 7 };

   inline int nGetPixelYLOfBigScaleTickBottom() {
      return( nGetPixelYLOfScaleTickTop() + nBigScaleTickHeight );
   }

   enum { nSpaceBetweenScaleTickAndNumber = 0 };


   inline int nGetPixelYLOfScaleNumber() {
      return( nGetPixelYLOfBigScaleTickBottom() +
              GuiApp::nGetFontAscent() +
              nSpaceBetweenScaleTickAndNumber );
   }

   enum { nSpaceBetweenScaleNumbersAndContigName = 1 };

   inline int nGetPixelYLOfContigName() {
      return( nGetPixelYLOfScaleNumber() +
              nSpaceBetweenScaleNumbersAndContigName +
              GuiApp::nGetFontAscent() );
   }

   enum { nSpaceBetweenContigNameAndInconsistentFwdRevPairs = 7 };

   inline int nGetPixelYLOfTopOfAreaForInconsistentFwdRevPairs() {
      return( nGetPixelYLOfContigName() +
              nSpaceBetweenContigNameAndInconsistentFwdRevPairs );
   }


   inline int nGetPixelYLOfBottomOfAreaForInconsistentFwdRevPairs() {
      return( nGetPixelYLOfTopOfAreaForInconsistentFwdRevPairs() +
              nHeightOfAreaForFwdRevPairsInSameScaffold_ );
   }

   enum { nSpaceBetweenScaffolds = 0 };

   inline int nGetHeightOfOneScaffold() {
      return( nGetPixelYLOfBottomOfAreaForInconsistentFwdRevPairs() +
              nSpaceBetweenScaffolds );
   }



   enum { nHeightOfMarginAtTopOfScreen = 0 };



   int nGetTopOfScaffold( const int nScaffold );

   inline int nGetPixelYOfScaffoldBaseline( const int nScaffold ) {
      return( nGetTopOfScaffold( nScaffold ) +
              nGetPixelYLOfScaffoldBaseline() );
   }


   inline int nGetPixelYOfScaleTickTop( const int nScaffold ) {
      return( nGetTopOfScaffold( nScaffold ) +
              nGetPixelYLOfScaleTickTop() );
   }


   inline int nGetPixelYOfScaleTickBottom( const int nScaffold,
                                           const eScaleTickType eTickType ) {

      return( nGetTopOfScaffold( nScaffold ) +
              ( eTickType == eBigTick ? nGetPixelYLOfBigScaleTickBottom() :
                ( eTickType == eMediumSizedTick ?
                  nGetPixelYLOfMediumSizedScaleTickBottom() :
                  nGetPixelYLOfLittleScaleTickBottom() 
                  ) )
              );
   }


   inline int nGetPixelYOfScaleNumber( const int nScaffold  ) {

      return( nGetTopOfScaffold( nScaffold ) +
              nGetPixelYLOfScaleNumber() );
   }


   inline int nGetPixelYOfContigName( const int nScaffold ) {

      return( nGetTopOfScaffold( nScaffold ) +
              nGetPixelYLOfContigName() );
   }



   inline int nGetPixelYOfConsistentFwdRevPairBaseline(
                                                                const int nScaffold ) {
      return( nGetTopOfScaffold( nScaffold ) +
              nGetPixelYLOfConsistentFwdRevPairBaseline() );
   }


   inline int nGetPixelYOfTopOfAreaForInconsistentFwdRevPairs(
                                                                       const int nScaffold ) {
      return( nGetTopOfScaffold( nScaffold ) +
              nGetPixelYLOfTopOfAreaForInconsistentFwdRevPairs() );
   }




   enum { nBaseOfTriangleThatSeparatesContigs = 10 };

   int nGetLeftEdgePixelX() {
      return 0;
   }
   int nGetRightEdgePixelX();
   int nGetTopEdgePixelY() {
      return 0;
   }
   int nGetBottomEdgePixelY();

   enum { nSizeOfRestrictionDigestMark = 10 };

   enum { nThicknessOfARestrictionDigestFragment = 10 };

   enum { nSpaceBetweenContigBarAndRestrictionFragments = 5 };

   inline int nGetPixelYTopOfAreaForAllRestrictionDigestEnzymes( 
          const int nScaffold ) {   
      return( nGetPixelYOfTopOfAreaForInconsistentFwdRevPairs( nScaffold ) 
              + nSpaceBetweenContigBarAndRestrictionFragments );
   }
              
   inline int nGetPixelYTopOfAreaForRestrictionDigestEnzyme(
          const int nScaffold,
          const int nEnzymeLine ) {
      return( nGetPixelYTopOfAreaForAllRestrictionDigestEnzymes( nScaffold ) +
              nEnzymeLine * nThicknessOfARestrictionDigestFragment );
   }

   inline int nGetPixelYBottomOfAreaForRestrictionDigestEnzyme(
          const int nScaffold,
          const int nEnzymeLine ) {
      return( nGetPixelYTopOfAreaForRestrictionDigestEnzyme( nScaffold,
                                                             nEnzymeLine ) +
              nThicknessOfARestrictionDigestFragment - 1 );
   }

   int nGetNumberOfDisplayedRestrictionEnzymes();

   inline int nGetPixelYBottomOfAreaForAllRestrictionDigestEnzymes(
                         const int nScaffold ) {
      return( nGetPixelYTopOfAreaForAllRestrictionDigestEnzymes( nScaffold ) +
              nGetNumberOfDisplayedRestrictionEnzymes() *
              nThicknessOfARestrictionDigestFragment - 1 );
   }


   enum { nHeightOfATagLine = 5 };

   enum { nSpaceBetweenRestrictionFragmentsAndTags = 5 };

   inline int nGetPixelYOfTagLine( const int nScaffold,
                                   const int nTagLine ) {

      return( 
         nGetPixelYBottomOfAreaForAllRestrictionDigestEnzymes( nScaffold ) +
         1 + 
         nSpaceBetweenRestrictionFragmentsAndTags + 
         nTagLine * nHeightOfATagLine );
   }


   int nGetPixelYBottomOfTagBar( const int nScaffold ) {

      // get the top of the last tag line and then add its
      // thickness and subtract 1
      return( nGetPixelYOfTagLine( nScaffold,
                                   pCP->nAssemblyViewNumberOfRowsOfTags_ )
              + nHeightOfATagLine - 1 );
   }

      

   inline bool bIsLineSegmentInThisSquare( int nX0,
                                           int nY0,
                                           int nX1,
                                           int nY1,
                                           const int nXIndex,
                                           const int nYIndex ) {

      // make sure that nX0 <= nX1
      if ( nX0 > nX1 ) {
         int nTemp = nX0;
         nX0 = nX1;
         nX1 = nTemp;
         nTemp = nY0;
         nY0 = nY1;
         nY1 = nTemp;
      }
         

      float fSquareLeft = nXIndex * pCP->dAssemblyViewGridCellWidthInPixels_;
      float fSquareRight = fSquareLeft + 
         pCP->dAssemblyViewGridCellWidthInPixels_;

      float fIntersectLeft = MAX( fSquareLeft, nX0 );
      float fIntersectRight = MIN( fSquareRight, nX1 );

      // remember that pixels increase downwards
      float fSquareTop = nYIndex * pCP->dAssemblyViewGridCellWidthInPixels_;
      float fSquareBottom = fSquareTop + 
         pCP->dAssemblyViewGridCellWidthInPixels_;

//                   (nX1, nY1)
//                  /^(fIntersectRight, fYAtRight)
//                 /
//                /
//               /
//              /
//    ---------/------------------<- fSquareTop
//    |       /                  |
//    |      /                   |
//    |     /                    |
//    |    /                     |
//    |   /                      |
//    |  /                       |
//    | /                        |
//    |/                         |
//    /                          |
//   /^(fIntersectLeft, fYAtLeft)|
//  / |                          |
//  (nX0, nY0 )                  |
//    |                          |
//    |                          |
//    ----------------------------<- fSquareBottom
//
//    ^fSquareLeft               ^fSquareBottom
//
//  My algorithm is to check if fYAtLeft and fYAtRight are either 
// both above the square or both below the square, then the line
// segment does not intersect the square.  However, anything else
// such as one above and one below, or one inside the square, means
// that the line segment intersects the square.
//

      assert( fIntersectLeft <= fIntersectRight );

      if ( nX0 != nX1 ) {
         float fSlope = ( nY1 - nY0 ) / (float) ( nX1 - nX0 );

         float fIntersept = nY1 - fSlope * nX1;

         float fYAtLeft = fSlope * fIntersectLeft + fIntersept;
         float fYAtRight = fSlope * fIntersectRight + fIntersept;

         // remember pixels increase downwards
         if ( ( fYAtLeft < fSquareTop && fYAtRight < fSquareTop ) ||
              ( fYAtLeft > fSquareBottom && fYAtRight > fSquareBottom ) ) {
            return( false );
         }
         else {
            return( true );
         }
      }
      else {
         // the line segment is vertical.  We just need to see
         // whether it's Y coordinates intersect the square

         if ( ( nY0 < fSquareTop && nY1 < fSquareTop ) ||
              ( nY0 > fSquareBottom && nY1 > fSquareBottom ) ) {
            return( false );
         }
         else {
            return( true );
         }
      }
   }

   GuiColorText* pGetGuiColorTextForRestrictionFragment( 
                                 restrictionFragment* pResFrag,
                                 const bool bHighlight );


public:


   Widget   widPopupShell_;
   Widget   widMainWin_;
   Widget   widMenuBar_;
   Widget   widForm_;
   Widget   widScrolledWin_;
   Widget   widHorizontalScrollBar_;
   Widget   widVerticalScrollBar_;
   Widget   widDrawingArea_;
   Widget   widDismissButton_;
   Widget   widZoomIn_;
   Widget   widZoomOut_;
   Widget   widZoomOriginal_;
   Widget   widMessageWindowAtBottom_;
   Widget   widFwdRevPairsWhatToShow_;
   Widget   widSequenceMatchesWhatToShow_;
   Widget   widContigArrangement_;
   Widget   widContigArrangementPopupMenu_;
   Widget   widIncludeContigs_;
   Widget   widTags_;
   Widget   widWhatToShowPopupMenu_;
   Widget   widReadDepth_;
   Widget   widGotoAlignedReadsWindow_;
   Widget   widMouseButton3PopupMenu_;
   Widget   widGotoTag_;
   Widget   widGotoFragment_;
   Widget   widDigestCutSites_;
   Widget   widHideOrShowTags_;
   Widget   widContigName_;


   GuiColorText* pGctContigs_;
   GuiColorText* pGctContigNames_;
   GuiColorText* pGctConsistentFwdRevPairs_;
   GuiColorText* pGctConsistentFwdRevPairDepth_;
   GuiColorText* pGctTooFewConsistentFwdRevPairs_;
   GuiColorText* pGctConsistentGapSpanningFwdRevPair_;
   GuiColorText* pGctInconsistentFwdRevPair_;
   GuiColorText* pGctScale_;
   GuiColorText* pGctScaleNumbers_;
   GuiColorText* pGctHighlight_;
   GuiColorText* pGctMultipleItemsOnTopOfEachOther_;
   GuiColorText* pGctDirectSequenceMatches_;
   GuiColorText* pGctInvertedSequenceMatches_;
   GuiColorText* pGctReadDepth_;
   GuiColorText* pGctDiscrepanciesNotIndels_;
   GuiColorText* pGctDiscrepanciesIndels_;


   enum { nMaxNumberOfRestrictionEnzymeLines = 10};
   GuiColorText* pGctConsistentRestrictionDigestFragment_[ nMaxNumberOfRestrictionEnzymeLines ];

   GuiColorText* pGctInconsistentRestrictionDigestFragment_;
   GuiColorText* pGctCloneEnd_;


   int nHeightOfAreaForFwdRevPairsInSameScaffold_;
   int nLongestScaffoldLength_;
   double dPixelWidthOfBase_;
   int nVerticalPixelsPerContig_;
   int nPixelIncrementToScroll_;
   int nPixelsScrolled_;
   int nLeftMarginPixelsWide_;
   int nLeftMarginBeforeName_;
   long lBasesPerScaleTick_;
   int nLeftEdgeScaffoldPos_;
   int nTopEdgeVirtualPixelPosition_;
   bool bFinishedComingUp_;
   int  nNumberOfScaffoldRows_;

   // what to show:
   bool bShowDepth_;
   bool bShowEachConsistentFwdRevPair_;
   bool bShowGapSpanningFwdRevPairs_;
   bool bShowConsistentFwdRevPairsBetweenDifferentScaffolds_;

   bool bShowDigest_;
   


   enum { nNO_INCONSISTENT_FWD_REV_PAIRS = 1,
          nFILTERED_INCONSISTENT_FWD_REV_PAIRS = 2,
          nALL_INCONSISTENT_FWD_REV_PAIRS = 3 };

   int nShowWhichInconsistentFwdRevPairs_;

   bool bShowLegsOnSquaresForConsistentFwdRevPairs_;
   bool bDoNotShowTemplatesInDoNotShowTemplatesFile_;

   RWTPtrOrderedVector<fwdRevPair2> aCurrentlyHighlightedFwdRevPairs_;
   int nNumberOfHighlightedPairsLastTime_;
   RWTPtrOrderedVector<fwdRevPair2> aClickedFwdRevPairs_;

   RWTPtrOrderedVector<seqMatch> aCurrentlyHighlightedSeqMatches_;
   RWTPtrOrderedVector<seqMatch> aClickedSeqMatches_;


   RWTPtrOrderedVector<tag> aCurrentlyHighlightedTags_;

   RWTPtrOrderedVector<restrictionFragment> aCurrentlyHighlightedFragments_;


   RWTPtrOrderedVector<clScaffold> aScaffolds_;

   arrayOfFwdRevPairTriangles aArrayOfFwdRevPairTriangles_;
   arrayOfFwdRevPairLines aArrayOfFwdRevPairLines_;
   arrayOfFwdRevPairSquares aArrayOfFwdRevPairSquares_;


   // order first by x, then by y
   RWT2DPtrVector<arrayOfSeqMatches>* p2DArrayOfArrayOfSeqMatches_;

   guiMultiContigNavigator* pGuiNav_;
   guiChoiceOfSeqMatches* pGuiChoiceOfSeqMatches_;

   RWTValOrderedVector<RWCString> aTemplatesToNotShow_;

   assemblyViewRemoveReads* pAssemblyViewRemoveReads_;

   // these are for the destructor
   guiReorderContigs*   pGuiReorderContigs_;
   guiReorientContigs*  pGuiReorientContigs_;
   bool                 bDoNotDeleteGuiReorderContigs_;
   bool                 bDoNotDeleteGuiReorientContigs_;

   RWTPtrOrderedVector<seqMatch> aSeqMatches_;

   bool bAlreadyReadCrossMatchOutput_;

   int nLastButtonPressPixelX_;
   int nLastButtonPressPixelY_;

   // indexed by scaffoldrow--not by scaffold
   RWTPtrOrderedVector<scaffoldLineTagBar> aScaffoldRowTagBars_;

   int nNumberOfColumnsOfTagCells_;

};



#endif