/***************************************************************************** # 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. # #*****************************************************************************/ // // guidraw.cpp // // implementation for GuiContigWin class // // gordon 6-March-1995 // #include #include #include #include #include #include using namespace std; #include #include #include "motifutils.h" #include "guiapp.h" #include "guicontigwin.h" #include "mbt_errors.h" #include "numutil.h" #include "contigwin.h" #include "consed.h" #include "consedParameters.h" //////////////////////////////////////////////////////////// // // PURPOSE: Clears all old bases so next redraw is able to // to just draw the bases until fragments end // // HOW TO USE IT: nothing to it // // INPUTS: nix // // OUTPUTS: nix // // REV: Feb 2, 1995 (David Gordon) // //////////////////////////////////////////////////////////// void GuiContigWin :: guiClearContigWindow() { XClearArea( XtDisplay( widContigWin_ ), XtWindow( widContigWin_ ), 0, 0, 0, 0, false ); } void GuiContigWin :: guiDrawScaleHorizontalLine() { XDrawLine( XtDisplay(widContigWin_), XtWindow( widContigWin_ ), pGctScale_->gcGet(), nFragmentBasesStartPixelX(), nScaleLinePixelY(), nGetContigWindowPixelWidth(), nScaleLinePixelY() ); } void GuiContigWin :: guiDrawScaleBigTick( const int nCharScreenPosition ) { int nPixelScreenPosition = nPixelXFromScreenChar( nCharScreenPosition ); int nMiddleOfCharPosition = (int) (nPixelScreenPosition + .5 * GuiApp::pGetGuiApp()->nGetFontWidth() ); XDrawLine(XtDisplay(widContigWin_), XtWindow( widContigWin_ ), pGctScale_->gcGet(), nMiddleOfCharPosition, // x1 nScaleLinePixelY(), // y1 nMiddleOfCharPosition, // x2 nScaleLinePixelY() + nScaleMarksHeight() ); // y2 } void GuiContigWin :: guiDrawScaleBigBigTick( const int nCharScreenPosition ) { int nPixelScreenPosition = nPixelXFromScreenChar( nCharScreenPosition ); int nMiddleOfCharPosition = (int) (nPixelScreenPosition + .5 * GuiApp::pGetGuiApp()->nGetFontWidth() ); XDrawLine(XtDisplay(widContigWin_), XtWindow( widContigWin_ ), pGctScale_->gcGet(), nMiddleOfCharPosition, // x1 nScaleLinePixelY(), // y1 nMiddleOfCharPosition, // x2 nScaleLinePixelY() + (int) ( 1.5 * nScaleMarksHeight()) ) ; // y2 } void GuiContigWin :: guiDrawScaleLittleTick( const int nCharScreenPosition ) { int nPixelScreenPosition = nPixelXFromScreenChar( nCharScreenPosition ); int nMiddleOfCharPosition = (int) (nPixelScreenPosition + .5 * GuiApp::pGetGuiApp()->nGetFontWidth() ); XDrawLine(XtDisplay(widContigWin_), XtWindow( widContigWin_ ), pGctScale_->gcGet(), nMiddleOfCharPosition, // x1 nScaleLinePixelY(), // y1 nMiddleOfCharPosition, // x2 nScaleLinePixelY() + (int) ( .3 * nScaleMarksHeight()) ); // y2 } void GuiContigWin :: guiDrawScaleNumber( const int nCharScreenPosition, char *szLabel ) { int nPixelScreenPosition = nPixelXFromScreenChar( nCharScreenPosition ); int nLen = strlen( szLabel ); // center the number around the base that it is numbering // Why the +1 ? This moves the number to the right another // half character width, thus centering it over the base. int nPixelOffset = ( ( nLen - 1 ) * GuiApp::pGetGuiApp()->nGetFontWidth() ) / 2; nPixelScreenPosition -= nPixelOffset; XDrawImageString( XtDisplay(widContigWin_), XtWindow( widContigWin_ ), pGctScaleNumbers_->gcGet(), nPixelScreenPosition, nScaleNumbersBaseline(), szLabel, nLen ); } //////////////////////////////////////////////////////////// // // PURPOSE: to draw a string of bases in the same color on // the same line // // HOW TO USE IT: // // // INPUTS: // // OUTPUTS: // // REV: (David Gordon) // // chrisa 9-mar-95 // now takes the postion of the sequencing direction // separator line into account // //////////////////////////////////////////////////////////// void GuiContigWin :: guiDrawReadColorWord(const int nScreenCharX, const int nReadLine, const char *szCharsToDraw, const int nNumberOfChars, GuiColorText* pGctToUse ) { int nStartXPixel; int nStartYPixel; nStartXPixel = nPixelXFromScreenChar( nScreenCharX ); nStartYPixel = nFragLineToPixelY( nReadLine ); if (nStartYPixel < 0 ) return; XDrawImageString( XtDisplay(widContigWin_), XtWindow( widContigWin_), pGctToUse->gcGet(), nStartXPixel, nStartYPixel, szCharsToDraw, nNumberOfChars); } // draws the consensus bases // will only draw a chunk of them that is the same color void GuiContigWin :: guiDrawConsensusColorWord(const int nScreenCharX, const char *szCharsToDraw, const int nNumberOfChars, GuiColorText* pGctToUse ) { int nStartXPixel; int nStartYPixel; nStartXPixel = nPixelXFromScreenChar( nScreenCharX ); nStartYPixel = nConsensusBaselinePixelY(), XDrawImageString( XtDisplay(widContigWin_), XtWindow( widContigWin_), pGctToUse->gcGet(), nStartXPixel, nStartYPixel, szCharsToDraw, nNumberOfChars); } void GuiContigWin :: guiDrawReadPrefix( const int nReadLine, const RWCString& soReadPrefix, GuiColorText* pGuiColorText ) { int nStartPixelX = nReadPrefixPixelX(); int nStartPixelY = nFragLineToPixelY( nReadLine ); XDrawImageString( XtDisplay( widContigWin_ ), XtWindow( widContigWin_ ), pGuiColorText->gcGet(), nStartPixelX, nStartPixelY, soReadPrefix.data(), MIN( soReadPrefix.length(), pCP->nMaxCharsDisplayedForReadPrefix_ ) ); } //////////////////////////////////////////////////////////// // // PURPOSE: draws a single fragment name // // REV: (David Gordon) Feb 22, 1995 // //////////////////////////////////////////////////////////// int GuiContigWin :: nGuiDrawFragmentName( const int nReadLine, const RWCString& soReadName, const bool bIsHighlighted ) { int nError; int nStartXPixel = nFragmentNameXPixelPosition(); int nStartYPixel = nFragLineToPixelY( nReadLine ); RWCString soReadNameThatFits = soReadName; if ( soReadNameThatFits.length() > nRoomForReadNames_ ) { soReadNameThatFits.keepOnlyLastPartOfString( nRoomForReadNames_ ); } GC gc; if (bIsHighlighted ) gc = pGctFragmentNamesHighlighted_->gcGet(); else gc = pGctFragmentNames_->gcGet(); nError = XDrawImageString( XtDisplay(widContigWin_), XtWindow( widContigWin_), gc, nStartXPixel, nStartYPixel, soReadNameThatFits, soReadNameThatFits.length() ); return( nError ); } //////////////////////////////////////////////////////////// // // PURPOSE: draws sequencing direction arrow // // REV: (David Gordon) Feb 23, 1995 // //////////////////////////////////////////////////////////// int GuiContigWin :: nGuiDrawSequencingDirectionArrow( const int nReadLine, const bool bFragmentComplemented, const bool bThisReadsTraceIsUp ) { int nStartXPixel; int nStartYPixel; int nError; XPoint aPoint[4]; //cout << "draw arrow at nLine = " << nLine << " comp = " << // bFragmentComplemented << endl; //cout.flush(); nStartXPixel = nDirectionIndicatorPixelX(); nStartYPixel = nDirectionIndicatorPixelY(nReadLine); if (bFragmentComplemented) { for( int nPoint = 0; nPoint < 4; ++nPoint ) { aPoint[ nPoint ].x = aPointLeft[ nPoint ].x + nStartXPixel; aPoint[ nPoint ].y = aPointLeft[ nPoint ].y + nStartYPixel; } } else { for( int nPoint = 0; nPoint < 4; ++nPoint ) { aPoint[ nPoint ].x = aPointRight[ nPoint ].x + nStartXPixel; aPoint[ nPoint ].y = aPointRight[ nPoint ].y + nStartYPixel; } } // XFillPolygon doesn't return anything--funny this has existed // for 10 years returning something (2005) XFillPolygon( XtDisplay(widContigWin_), XtWindow( widContigWin_), ( bThisReadsTraceIsUp ? pGctSequencingDirectionTraceIsUp_->gcGet() : pGctSequencingDirection_->gcGet() ), aPoint, 4, Convex, CoordModeOrigin ); return( 1 ); } void GuiContigWin :: guiDrawConsensusLabel() { XDrawImageString( XtDisplay(widContigWin_), XtWindow( widContigWin_), (( pContigWin_->nIndexOfTopVisibleRead_ == 0 ) ? pGctConsensusLabel_->gcGet() : pGuiColorTextWhenVerticalScrollbarScrolledDown_->gcGet() ), nFragmentNameXPixelPosition(), nConsensusBaselinePixelY(), "CONSENSUS", strlen( "CONSENSUS" ) ); } void GuiContigWin :: guiDrawConsensusSeparatorLine() { // draw the consensus separator line XDrawLine( XtDisplay(widContigWin_), XtWindow( widContigWin_ ), (( pContigWin_->nIndexOfTopVisibleRead_ == 0 ) ? pGctConsensusLabel_->gcGet() : pGuiColorTextWhenVerticalScrollbarScrolledDown_->gcGet() ), nFragmentBasesStartPixelX(), nConsensusSeparatorLinePixelY(), nGetContigWindowPixelWidth(), nConsensusSeparatorLinePixelY() ); } // draw a single consensus char, at passed screen relative // position // This is used to draw the cursor, or to blink off the cursor void GuiContigWin :: guiDrawOneConsensusChar(const char cBase, const int nScreenCharPos, GuiColorText* pGctToUse) { // transfer base to null terminated string for X draw routine char szBase[2]; szBase[0] = cBase; szBase[1] = '\0'; int nStartXPixel = nPixelXFromScreenChar( nScreenCharPos ); XDrawImageString(XtDisplay(widContigWin_), XtWindow( widContigWin_), pGctToUse->gcGet(), nStartXPixel, nConsensusBaselinePixelY(), szBase, 1 ); } // draws the line that separates the forward & reverse reads void GuiContigWin :: nGuiDrawSepLine() const { XDrawLine(XtDisplay(widContigWin_), XtWindow( widContigWin_ ), pGctSequencingDirection_->gcGet(), nDirectionIndicatorPixelX(), nDirectionSepLinePixelY(), nGetContigWindowPixelWidth(), nDirectionSepLinePixelY() ); } int GuiContigWin :: nFragLineToPixelY( int nFragLine ) const { // nFragLine is 0-based int nPix; int nScreenLine = nFragLine - pContigWin_->nIndexOfTopVisibleRead_; // nScreenLine is zero based also if (nScreenLine < 0 ) return( -1 ); if ( !pContigWin_->bDrawSeparatorBetweenTopAndBottomStrandReads() ) { nPix = nForFragLineBaselinePixelY() + GuiApp::nGetFontHeight() * nScreenLine; } else { if (nScreenLine >= nForFragsVisible()) { // the frag line is in the reverse area, after showing // some forward reads and the forward/reverse separator line // yes, so offset from start of the reverse lines int nReverseLine = nScreenLine - nForFragsVisible(); nPix = nRevFragLineBaselinePixelY() + GuiApp::nGetFontHeight() * nReverseLine; } else { // case in which this fragment is in the forward read area nPix = nForFragLineBaselinePixelY() + GuiApp::nGetFontHeight() * nScreenLine; } } return nPix; } int GuiContigWin :: nGetFragmentBasesMaxPixelY() { return nRevFragLineTopPixelY() + ( nRevFragsVisible() * GuiApp::nGetFontHeight() ); } void GuiContigWin :: guiDrawHalfCharacterTag( const bool bReadTagNotConsensusTag, const int nScreenCharX, const int nReadLine, const int nNumberOfChars, GuiColorText* pGctToUse ) { int nStartXPixel = nPixelXFromScreenChar( nScreenCharX ); int nWidth = ( GuiApp::nGetFontWidth() * nNumberOfChars ); int nBottomPixel; if (bReadTagNotConsensusTag ) { nBottomPixel = nFragLineToPixelY( nReadLine ) + GuiApp::nGetFontDescent() - 1; } else { nBottomPixel = nConsensusBaselinePixelY() + GuiApp::nGetFontDescent() - 1; } int nHeight = ( GuiApp::nGetFontHeight() * consedParameters::pGetConsedParameters()->nTagColorPerCentOfBase_ )/100; int nTopYPixel = nBottomPixel - nHeight + 1; if ( (nTopYPixel + nHeight) < 0 ) return; XFillRectangle( XtDisplay(widContigWin_), XtWindow( widContigWin_ ), pGctToUse->gcGetReverse(), nStartXPixel, nTopYPixel, nWidth, nHeight ); } void GuiContigWin :: guiDrawBasesWithoutBackground( const bool bReadNotConsensus, const int nScreenCharX, const int nReadLine, const RWCString& soBasesToDraw, GuiColorText* pGctToUse ) { int nStartXPixel; int nStartYPixel; nStartXPixel = nPixelXFromScreenChar( nScreenCharX ); if (bReadNotConsensus ) nStartYPixel = nFragLineToPixelY( nReadLine ); else nStartYPixel = nConsensusBaselinePixelY(); if (nStartYPixel < 0 ) return; XDrawString( XtDisplay(widContigWin_), XtWindow( widContigWin_), pGctToUse->gcGet(), nStartXPixel, nStartYPixel, (char*) soBasesToDraw.data(), soBasesToDraw.length() ); } void GuiContigWin :: guiDrawAminoAcid( const char cAminoAcid, const int nScreenCharX, const int nReadingFrame, GuiColorText* pGctToUse ) { int nStartXPixel = nPixelXFromScreenChar( nScreenCharX ); int nStartYPixel = nReadingFrameToPixelY( nReadingFrame ); XDrawString( XtDisplay( widContigWin_), XtWindow( widContigWin_), pGctToUse->gcGet(), nStartXPixel, nStartYPixel, &cAminoAcid, 1 ); // number of chars } void GuiContigWin :: guiDrawProteinTranslationLabel( char* szLabel, const int nReadingFrame ) { int nStartXPixel = nFragmentNameXPixelPosition(); int nStartYPixel = nReadingFrameToPixelY( nReadingFrame ); XDrawString( XtDisplay( widContigWin_ ), XtWindow( widContigWin_ ), pGctProteinTranslationLabels_->gcGet(), nStartXPixel, nStartYPixel, szLabel, strlen( szLabel ) ); } void GuiContigWin :: guiDrawVerticalLineAtCursor( const int nScreenCharPos ) { int nPixelScreenPosition = nPixelXFromScreenChar( nScreenCharPos ); // the +2 is so it the line doesn't go through the middle of T's int nMiddleOfCharPosition = (int) ( nPixelScreenPosition + .5 * GAPP->nGetFontWidth() ) + 2; // do not try to draw beyond end of window--fixed June 2009 in // which green line would not go all the way down (see notes June 24, 2009) int nMaxPixel = nGetContigWindowPixelHeight(); int nBottomPixelY = nGetFragmentBasesMaxPixelY(); if ( nBottomPixelY > nMaxPixel ) { nBottomPixelY = nMaxPixel; } XDrawLine( XtDisplay( widContigWin_ ), XtWindow( widContigWin_ ), pGctVerticalLineAtCursor_->gcGet(), nMiddleOfCharPosition, nConsensusSeparatorLinePixelY(), nMiddleOfCharPosition, nBottomPixelY ); } void GuiContigWin :: guiDrawHorizontalLineAtCursor( const int nReadLine ) { int nPixelY = nFragLineToPixelY( nReadLine ) + GuiApp::nGetFontDescent() - 1; int nPixelXLeft = 0; int nPixelXRight = nGetContigWindowPixelWidth(); XDrawLine( XtDisplay( widContigWin_ ), XtWindow( widContigWin_ ), pGctHorizontalLineAtCursor_->gcGet(), nPixelXLeft, nPixelY, nPixelXRight, nPixelY ); }