#include "GameStateDisplay.h"

#include "common.h"
#include "SpriteResource.h"
#include "GameStateEditor.h"

#include "minorGems/graphics/openGL/gui/TextGL.h"
#include "minorGems/util/stringUtils.h"


extern TextGL *largeText;



GameStateDisplay::GameStateDisplay( int inAnchorX, int inAnchorY,
                                    char inShowObjectToolTips )
        : GUIComponentGL( inAnchorX, inAnchorY,
                          G * P, G * P ),
          mHasAnySpeechBeenAutoFlipped( false ),
          mManualBubblePositioningLive( false ),
          mLastPixelClickX( 0 ), mLastPixelClickY( 0 ),
          mLastGridClickX( 0 ), mLastGridClickY( 0 ),
          mLastActionRelease( false ),
          mLastActionPress( false ),
          mLastActionKeyPress( false ),
          mLastMouseoverObjectIndex( -1 ),
          mMouseHover( false ),
          mLastHoverGridX( 0 ), mLastHoverGridY( 0 ),
          mEditingSpeech( false ),  
          mEditingAction( false ),
          mHighlightEditedBubble( false ),
          mShowObjectToolTips( inShowObjectToolTips ),
          mEditor( NULL ),
          mFocused( false ),
          mShowGrid( true ),
          mHintMode( false ),
          mState( NULL ),
          mLastSelected( -1 ),
          mBlinkCycle( 0 ) {


    for( int y=0; y<G; y++ ) {
        for( int x=0; x<G; x++ ) {
            mSprites[y][x] = NULL;
            }
        }

    mBubbleTopSprite = new Sprite( "bubbleTop.tga", true );
    mBubbleMiddleSprite = new Sprite( "bubbleMiddle.tga", true );
    mBubbleMiddleExtraSprite = new Sprite( "bubbleMiddleExtra.tga", true );
    mBubbleMiddleExtraThinSprite = new Sprite( "bubbleMiddleExtraThin.tga", 
                                               true );
    mBubbleBottomSprite = new Sprite( "bubbleBottom.tga", true );
    mBubbleBottomSpriteFlip = new Sprite( "bubbleBottomFlip.tga", true );
    mBubbleBottomNoTailSprite = new Sprite( "bubbleBottomNoTail.tga", true );
    mBubbleMiddleTailSprite = new Sprite( "bubbleMiddleTail.tga", true );
    mBubbleMiddleTailFlipSprite = 
        new Sprite( "bubbleMiddleTailFlip.tga", true );


    mSpeechBoxTopSprite = new Sprite( "speechBoxTop.tga", true );
    mSpeechBoxBottomSprite = new Sprite( "speechBoxBottom.tga", true );

    mActionBoxStartSprite = new Sprite( "actionBoxStart.tga", true );
    mActionBoxMiddleSprite = new Sprite( "actionBoxMiddle.tga", true );
    mActionBoxMiddleExtraSprite = 
        new Sprite( "actionBoxMiddleExtra.tga", true );
    mActionBoxEndSprite = new Sprite( "actionBoxEnd.tga", true );
    mActionBoxEndFlipSprite = new Sprite( "actionBoxEndFlip.tga", true );


    mActionBoxStartTallSprite = new Sprite( "actionBoxStartTall.tga", true );
    mActionBoxMiddleTallSprite = new Sprite( "actionBoxMiddleTall.tga", true );
    mActionBoxMiddleExtraTallSprite = 
        new Sprite( "actionBoxMiddleExtraTall.tga", true );
    mActionBoxEndTallSprite = new Sprite( "actionBoxEndTall.tga", true );
    mActionBoxEndFlipTallSprite = new Sprite( "actionBoxEndFlipTall.tga", true );
    }



GameStateDisplay::~GameStateDisplay() {
    for( int y=0; y<G; y++ ) {
        for( int x=0; x<G; x++ ) {
            if( mSprites[y][x] != NULL ) {
                delete mSprites[y][x];
                }
            }
        }

    int numSprites = mObjectSprites.size();
    for( int s=0; s<numSprites; s++ ) {
        delete *( mObjectSprites.getElement( s ) );
        }
    

    if( mState != NULL ) {
        delete mState;
        }

    delete mBubbleTopSprite;
    delete mBubbleMiddleSprite;
    delete mBubbleMiddleExtraSprite;
    delete mBubbleMiddleExtraThinSprite;
    delete mBubbleBottomSprite;
    delete mBubbleBottomSpriteFlip;
    delete mBubbleBottomNoTailSprite;
    delete mBubbleMiddleTailSprite;
    delete mBubbleMiddleTailFlipSprite;

    delete mSpeechBoxTopSprite;
    delete mSpeechBoxBottomSprite;

    delete mActionBoxStartSprite;
    delete mActionBoxMiddleSprite;
    delete mActionBoxMiddleExtraSprite;
    delete mActionBoxEndSprite;
    delete mActionBoxEndFlipSprite;

    delete mActionBoxStartTallSprite;
    delete mActionBoxMiddleTallSprite;
    delete mActionBoxMiddleExtraTallSprite;
    delete mActionBoxEndTallSprite;
    delete mActionBoxEndFlipTallSprite;
    }


        
void GameStateDisplay::setEditor( void *inEditor ) {
    mEditor = inEditor;
    }

    
    

void GameStateDisplay::setState( GameState *inState ) {
    
    //printf( "Before updating state, %d sprites\n", mObjectSprites.size() );
    
    
    /*
    char newRoom = false;
    
    if( !equal( inState.mRoom.getID(), mState.mRoom.getID() ) {
        newRoom = true;
        }
    */
    if( mState != NULL ) {
        delete mState;
        }

    mState = inState;

        
    for( int y=0; y<G; y++ ) {
        for( int x=0; x<G; x++ ) {
            if( mSprites[y][x] != NULL ) {
                delete mSprites[y][x];
                }

            Tile t( mState->mRoom.getTile( x, y ) );
            
            mSprites[y][x] = t.getSprite();
            }
        }


    // clear old
    int numSprites = mObjectSprites.size();
    int i;
    for( i=0; i<numSprites; i++ ) {
        delete *( mObjectSprites.getElement( i ) );
        }
    mObjectSprites.deleteAll();
    mObjectSpritePositions.deleteAll();
    mObjectSpriteOwners.deleteAll();
    mObjectSpriteTrans.deleteAll();
    mObjectSpriteGlows.deleteAll();
    mObjectSpriteDepth.deleteAll();
    mObjectSpriteLocked.deleteAll();
    
    mSpeechOffTop.deleteAll();
    

    // add new
    int numObjects = mState->mObjects.size();

    // flag for 0
    mSpeechOffTop.push_back( false );
    

    // add 0 (player object) last so it's always on top
    for( i=1; i<numObjects; i++ ) {
        mSpeechOffTop.push_back( false );
        addSpritesFromStateInstance( i );
        }

    // now do 0 
    addSpritesFromStateInstance( 0 );
    

    //printf( "After updating state, %d sprites\n", mObjectSprites.size() );

    recomputeDrawOrderMap();
    }




void GameStateDisplay::addSpritesFromStateInstance( int inIndex ) {
    

    int i = inIndex;
    
    StateObjectInstance *o = *( mState->mObjects.getElement( i ) );
    
        
    int numSprites = o->mObject.getNumLayers();
    
    intPair anchorPos = o->mAnchorPosition;
    
    int depth = G - (anchorPos.y / P) - 1;
    
    for( int s=0; s<numSprites; s++ ) {
            
        SpriteResource resource( o->mObject.getLayerSprite( s ) );
            
        mObjectSprites.push_back( resource.getSprite() );
            
            
        intPair p = o->mObject.getLayerOffset( s );
            
        p = ::add( p, anchorPos );
            
        mObjectSpritePositions.push_back( p );
        // no owner flags for non-anchors
        mObjectSpriteOwners.push_back( -1 );

        float trans =
            ( o->mObjectTrans / 255.0f ) *
            ( o->mObject.getLayerTrans( s ) / 255.0f );

        mObjectSpriteTrans.push_back( trans );
        
        mObjectSpriteGlows.push_back( o->mObject.getLayerGlow( s ) );

        mObjectSpriteDepth.push_back( depth );

        mObjectSpriteLocked.push_back( o->mLocked );
        }

    // last, add anchor sprite for this object, on top
    if( i==0 ) {
        // special anchor for player
        mObjectSprites.push_back( new Sprite( "playerAnchor.tga", true ) );
        }
    else {
        mObjectSprites.push_back( new Sprite( "anchor.tga", true ) );
        }
    
    mObjectSpritePositions.push_back( o->mAnchorPosition );
    // only "own" the anchors
    mObjectSpriteOwners.push_back( i );

    // anchors ignore trans and glow
    mObjectSpriteTrans.push_back( 1.0 );
    mObjectSpriteGlows.push_back( false );

    // anchors are all on top
    mObjectSpriteDepth.push_back( G );

    mObjectSpriteLocked.push_back( o->mLocked );
    }


        
int GameStateDisplay::updatePositionFromStateInstance( int inIndex,
                                                       int inSpriteIndex ) {
    int i = inIndex;
    

    StateObjectInstance *o = *( mState->mObjects.getElement( i ) );

        
    int numSprites = o->mObject.getNumLayers();

    intPair anchorPos = o->mAnchorPosition;
    
    int depth = G - (anchorPos.y / P) - 1;

    for( int s=0; s<numSprites; s++ ) {
        intPair p = o->mObject.getLayerOffset( s );
        
        p = ::add( p, anchorPos );
        
        *( mObjectSpritePositions.getElement( inSpriteIndex ) ) = p;
        
        float trans =
            ( o->mObjectTrans / 255.0f ) *
            ( o->mObject.getLayerTrans( s ) / 255.0f );

        *( mObjectSpriteTrans.getElement( inSpriteIndex ) ) = trans;

        *( mObjectSpriteGlows.getElement( inSpriteIndex ) ) = 
            o->mObject.getLayerGlow( s );
        
        *( mObjectSpriteDepth.getElement( inSpriteIndex ) ) = depth;
        
        *( mObjectSpriteLocked.getElement( inSpriteIndex ) ) = o->mLocked;

        inSpriteIndex++;
        }
    
    
    *( mObjectSpritePositions.getElement( inSpriteIndex ) ) = 
        o->mAnchorPosition;
    
    *( mObjectSpriteTrans.getElement( inSpriteIndex ) ) = 1.0;

    *( mObjectSpriteGlows.getElement( inSpriteIndex ) ) = false;
    
    *( mObjectSpriteLocked.getElement( inSpriteIndex ) ) = o->mLocked;
    
        
    inSpriteIndex++;


    return inSpriteIndex;
    }



void GameStateDisplay::updateSpritePositions( GameState *inState ) {
    
    if( mState != NULL ) {
        delete mState;
        }

    mState = inState;


    int numObjects = mState->mObjects.size();
    
    int spriteIndex = 0;
    
    // 0 last (player object on top)
    for( int i=1; i<numObjects; i++ ) {
        spriteIndex = updatePositionFromStateInstance( i, spriteIndex );
        }

    // now 0
    spriteIndex = updatePositionFromStateInstance( 0, spriteIndex );

    recomputeDrawOrderMap();
    }



void GameStateDisplay::recomputeDrawOrderMap() {
    mDrawOrderMap.deleteAll();
    
    // G+1 bins
    SimpleVector<int> depthBins[ G + 1 ];
    
    int numSprites = mObjectSprites.size();
    
    
    // put locked ones in first (behind) for each depth
    for( int i=0; i<numSprites; i++ ) {
        if( *( mObjectSpriteLocked.getElement( i ) ) ) {
            
            int depth = *( mObjectSpriteDepth.getElement( i ) );
            depthBins[depth].push_back( i );
            }
        }

    // now unlocked ones in front at each depth
    for( int i=0; i<numSprites; i++ ) {
        if( ! *( mObjectSpriteLocked.getElement( i ) ) ) {
            
            int depth = *( mObjectSpriteDepth.getElement( i ) );
            depthBins[depth].push_back( i );
            }
        }
    
    
    // dump bins in, in order
    for( int b=0; b<=G; b++ ) {
        
        int binSize = depthBins[b].size();
        
        for( int i=0; i<binSize; i++ ) {
            mDrawOrderMap.push_back( *( depthBins[b].getElement( i ) ) );
            }        
        }
    }



void GameStateDisplay::showGrid( char inShow ) {
    mShowGrid = inShow;
    }



void GameStateDisplay::setHintMode( char inHintsOnly ) {
    mHintMode = inHintsOnly;
    }



void GameStateDisplay::copySpeechCoordinates( GameState *inDestinationState ) {
    int numObjects = mState->mObjects.size();
    
    for( int i=0; i<numObjects; i++ ) {
        StateObjectInstance *o = *( mState->mObjects.getElement( i ) );
        
        StateObjectInstance *oDest = 
            *( inDestinationState->mObjects.getElement( i ) );


        oDest->mSpeechFlip = o->mSpeechFlip;
        oDest->mSpeechOffset = o->mSpeechOffset;
        }
    }



char GameStateDisplay::getSpeechOffTop( int inObject ) {
    return *( mSpeechOffTop.getElement( inObject ) );
    }

    


void GameStateDisplay::drawSpeech( int inIndex ) {
    int i = inIndex;

    int selected = mState->getSelectedObject();

    Color *bubbleColor = NULL;


    StateObjectInstance *o = *( mState->mObjects.getElement( i ) );
        
    // skip any blank messages
    // UNLESS we are editing text of selected
    if( strlen( o->mSpokenMessage ) >  0
        ||
        ( i == selected && mEditingSpeech ) ) {
        

        if( i == selected && isFocused() && mHighlightEditedBubble ) {
            bubbleColor = new Color( 1.0f, 1.0f, 0.5f, 1.0f );
            }
        

        intPair pos = ::add( o->mSpeechOffset, o->mAnchorPosition );
        
        double height = 8;
        double width = strlen( o->mSpokenMessage ) * height;
      

        double trueStringHeight = height * 
            largeText->measureTextHeight( o->mSpokenMessage );
        
        char bubbleHasHighLines = false;
        char bubbleHasReallyHighLines = false;
        
        if( trueStringHeight > 8 ) {
            // make room for high characters
            bubbleHasHighLines = true;
            }
        if( trueStringHeight > 9 ) {
            bubbleHasReallyHighLines = true;
            }
        
        

        int bubbleWidth = 64 - 8;
        
  


        SimpleVector<char*> lines;

        
        // new code:  split into words first, ingore player's spacing.
        // 1 space between words, two spaces after a period
        SimpleVector<char*> *words = tokenizeString( o->mSpokenMessage );
        
        int wordIndex = 0;
        int numWords = words->size();
        
        while( wordIndex < numWords ) {
            // a word left
            char *nextWord = *( words->getElement( wordIndex ) );
            double nextWordWidth =  
                largeText->measureTextWidth( nextWord ) * height;

            char *currentLine = NULL;
            double currentWidth = 0;
            int numLines = lines.size();
            
            if( numLines > 0 ) {
                
                currentLine = *( lines.getElement( numLines - 1 ) );
                currentWidth = 
                    largeText->measureTextWidth( currentLine ) * height;
                }
            
            char *spaceNeeded = (char *)" ";
            int lastCharIndex = -1;
            if( currentLine != NULL ) {
                lastCharIndex = strlen( currentLine ) - 1;
                }
            
            if( currentLine != NULL &&
                ( currentLine[ lastCharIndex ] == '.' ||
                  currentLine[ lastCharIndex ] == '?' ||
                  currentLine[ lastCharIndex ] == '!' ) ) {
                // line so far ends with period (or other sentence ender), 
                // extra space before next word in line
                spaceNeeded = (char *)"  ";
                }
            double spaceWidth = 
                largeText->measureTextWidth( spaceNeeded ) * height;

            if( currentLine != NULL &&
                currentWidth + spaceWidth + nextWordWidth 
                < bubbleWidth ) {
                
                // good!  we can add it
                char *newLine = autoSprintf( "%s%s%s", currentLine,
                                             spaceNeeded, nextWord );
                delete [] currentLine;
                *( lines.getElement( numLines - 1 ) ) = newLine;
                
                delete [] nextWord;
                }
            else {
                // not enough room on this line, or no line yet
                // start a new one with just this word
                
                if( nextWordWidth < bubbleWidth ) {
                    lines.push_back( nextWord );
                    }
                else {
                    // problem!  really long word
                
                    // split it into parts... make sure second part has at 
                    // least 3 chars
                    
                    char *partialWord = stringDuplicate( nextWord );

                    double hypenWidth = largeText->measureTextWidth( "-" );

                    while( ( hypenWidth + 
                             largeText->measureTextWidth( partialWord ) )
                           * height
                           >= bubbleWidth ) {
                    
                        // truncate
                        partialWord[ strlen( partialWord ) - 1 ] = '\0';
                        }

                    int partialLength = strlen( partialWord );
                    
                    int nextWordLength = strlen( nextWord );
                    
                    int extraLength = nextWordLength - partialLength;
                    
                    while( extraLength < 3 ) {
                        // trim more off partial
                        partialWord[ partialLength - 1 ] = '\0';
                        
                        partialLength -= 1;
                    
                        extraLength ++;
                        }
                    
                    // add hyphen
                    partialWord[ partialLength ] = '-';
                    partialWord[ partialLength + 1 ] = '\0';
                    
                    lines.push_back( partialWord );
                    
                    char *extraChars = stringDuplicate( 
                        &( nextWord[ partialLength ] ) );
                    
                    *( words->getElement( wordIndex ) ) = extraChars;
                    delete [] nextWord;
                    
                    // part of the word still there, back up and look 
                    // at it again
                    wordIndex --;
                    }
                }
            wordIndex ++;
            }
        delete words;        





        // start at bottom line and draw up
        double bubbleFade = 0.63;
        
        int flipSign = 1;
            
        if( o->mSpeechFlip ) {
            flipSign = -1;
            }
            

        // draw bottom w/ tip at anchor
        Vector3D bubblePos( mAnchorX + pos.x + flipSign * 32,
                            mAnchorY + pos.y + 7,
                            0 );
        
        
        
        if( o->mSpeechBox ) {
            bubblePos.mY -= 8;
            }
        

        int numLines = lines.size();
        
        int bubbleHeight = 7 + 9 * numLines + 7;
        
        if( bubbleHasHighLines ) {
            
            if( bubbleHasReallyHighLines ) {
                // use extended mode
                bubbleHeight = 7 + 12 * numLines + 7;
                }
            else {
                // thin extended mode
                bubbleHeight = 7 + 10 * numLines + 7;
                }
            }
        
        
        char offTop = false;
        
        if( bubblePos.mY + bubbleHeight > mHeight + mAnchorY ) {
            offTop = true;
            }

        char oldOffTop = *( mSpeechOffTop.getElement( i ) );
        
        
        *( mSpeechOffTop.getElement( i ) ) = offTop;
        
        if( offTop != oldOffTop ) {
            // a change in off-top status.  Tell editor about it
            mHasAnySpeechBeenAutoFlipped = true;
            }
        

        // auto-flip if off the side of screen

        char flipThisBubble = o->mSpeechFlip;
        
        int bubbleHalfWidth =  32;
        int bubbleFullWidth =  64;
        
        // off-top boxes are no wider
        if( ! o->mSpeechBox &&
            offTop && numLines > 0 ) {
            bubbleHalfWidth += 10;
            }


        // apply flipping heuristic positioning
        int autoFlipExtraOffset = mState->getAutoOffsetOnFlip( i );
        
        if( mManualBubblePositioningLive ) {
            // don't mess with the mouse, drop heuristic and go with 
            // mouse position
            autoFlipExtraOffset = 0;
            }
        


        if( o->mSpeechFlip && bubblePos.mX - bubbleHalfWidth < mAnchorX ) {
            // unflip
            flipThisBubble = false;
            bubblePos.mX += bubbleFullWidth;
            bubblePos.mX += autoFlipExtraOffset;

            // auto-flip this bubble for the future, too, so that mouse-based
            // positioning
            // works correctly, etc
            o->mSpeechFlip = false;
            o->mSpeechOffset.x += autoFlipExtraOffset;
            // thus, we WON'T have to auto-flip next time we draw this same
            // frame
            mHasAnySpeechBeenAutoFlipped = true;
            }
        else if( ! o->mSpeechFlip && bubblePos.mX + bubbleHalfWidth >
                 mWidth + mAnchorX ) {
            // force a flip
            flipThisBubble = true;
            bubblePos.mX -= bubbleFullWidth;
            bubblePos.mX += autoFlipExtraOffset;
            
            // again, permanently re-flip
            o->mSpeechFlip = true;
            o->mSpeechOffset.x += autoFlipExtraOffset;
            mHasAnySpeechBeenAutoFlipped = true;
            }

        
        if( o->mSpeechFlip ) {
            bubblePos.mX += 1;
            }
        

        Sprite *bottomSprite = mBubbleBottomSprite;
        Sprite *middleTailSprite = mBubbleMiddleTailSprite;
            

        if( flipThisBubble ) {
            bottomSprite = mBubbleBottomSpriteFlip;
            middleTailSprite = mBubbleMiddleTailFlipSprite;
            }
        if( o->mSpeechBox ) {
            bottomSprite = mSpeechBoxBottomSprite;
            // no middle tails
            middleTailSprite = mBubbleMiddleSprite;
            }
        
            
        int lineWithTail = 0;
        
        if( offTop ) {
            if( !o->mSpeechBox ) {
                
                if( numLines > 0 ) {
                    bottomSprite = mBubbleBottomNoTailSprite;
                    // scoot over to make room for horizontal tail
                    if( flipThisBubble ) {
                        bubblePos.mX -= 10;
                        }
                    else {
                        bubblePos.mX += 10;
                        }
                    
                
                

                
                    // scoot the whole thing down by some number of lines
                    int linesToScoot = numLines;
                    //lineWithTail = numLines - 1;
                
                    while( bubblePos.mY + bubbleHeight > mHeight + mAnchorY
                           &&
                           linesToScoot > 0 ) {
                        bubblePos.mY -= 9;
                        if( linesToScoot == numLines ) {
                            // anchor pos for bubble is above bottom tail, now
                            // up aligned with a line instead.
                            bubblePos.mY -= 10;
                            }
                    
                        linesToScoot --;
                        }
                    //bubblePos.mY -= 10;

                    // how many lines left?
                    lineWithTail = linesToScoot;
                    }
                }
            else {
                // simply flush boxes with top... no tail to align!
                bubblePos.mY -= 
                    (bubblePos.mY + bubbleHeight) 
                    - (mHeight + mAnchorY);
                }
            
            }
        


        bottomSprite->draw( 0, 0, &bubblePos, 1, 
                            bubbleFade,
                            bubbleColor );
            
        bubblePos.mY += 4;

        // draw lines of text last, to ensure they're on top of bubble parts
        double *lineY = new double[numLines];
        
        
        for( int i=numLines-1; i>=0; i-- ) {
            bubblePos.mY += 8;

            if( i < numLines - 1 ) {
                // extra space for all but bottom line
                bubblePos.mY += 1;
                }
            if( bubbleHasHighLines ) {
                // extended line height mode
                
                if( i < numLines - 1 ) {
                    // extra space for all but bottom line
                    bubblePos.mY += 1;

                    if( bubbleHasReallyHighLines ) {
                        bubblePos.mY += 2;
                        }
                    }
                // padding above all but top line
                if( i > 0 ) {
                    
                    if( bubbleHasReallyHighLines ) {
                        
                        mBubbleMiddleExtraSprite->draw( 0, 0, &bubblePos, 1, 
                                                        bubbleFade,
                                                        bubbleColor );
                        }
                    else {
                        mBubbleMiddleExtraThinSprite->draw( 
                            0, 0, &bubblePos, 1, 
                            bubbleFade,
                            bubbleColor );
                        }
                    }
                
                }
            
            
            if( offTop && lineWithTail == i ) {
                // normal line
                middleTailSprite->draw( 0, 0, &bubblePos, 1, 
                                        bubbleFade,
                                        bubbleColor );
                }
            else {
                // normal line
                mBubbleMiddleSprite->draw( 0, 0, &bubblePos, 1, 
                                           bubbleFade,
                                           bubbleColor );
                }
            
            lineY[i] = bubblePos.mY - 4;
            /*
            char *line = *( lines.getElement( i ) );
            
            width = strlen( line ) * height;
            
            glColor4f( 0, 0, 0, 1 );

            largeText->drawText( line, 
                                 bubblePos.mX - 32 + 4,
                                 bubblePos.mY - 4,
                                 width, height );
            delete [] line;
            */
            }        
        
        bubblePos.mY += 7;
        if( numLines > 0 ) {
            // extra space before top
            bubblePos.mY += 1;
            }
        
        if( o->mSpeechBox ) {
            // flip, because this one is upside down in file (so lower
            // corner can have transparency)
            mSpeechBoxTopSprite->draw( 0, 0, &bubblePos, -1, bubbleFade,
                                       bubbleColor );
            }
        else {
            mBubbleTopSprite->draw( 0, 0, &bubblePos, 1, bubbleFade,
                                    bubbleColor );
            }

        // lines last 
        for( int i=numLines-1; i>=0; i-- ) {
            
            char *line = *( lines.getElement( i ) );
            
            width = strlen( line ) * height;
            
            glColor4f( 0, 0, 0, 1 );

            largeText->drawText( line, 
                                 bubblePos.mX - 32 + 4,
                                 lineY[i],
                                 width, height );
            delete [] line;
            }
        delete []lineY;
        }
    
    

    if( bubbleColor != NULL ) {
        delete bubbleColor;
        }
    
    }



// defined in ScreenGL_SDL.cpp

// we draw object hint mode differently depending on this
extern char screenGLStencilBufferSupported;

      

void GameStateDisplay::fireRedraw() {
    
    // invisible if disabled
    if( !mEnabled ) {
        return;
        }
    

    if( ! mHintMode ) {
        
        double roomTrans = mState->mRoomTrans / 255.0;
    
        for( int y=0; y<G; y++ ) {
            for( int x=0; x<G; x++ ) {
                if( mSprites[y][x] != NULL ) {    
                    Vector3D pos( mAnchorX + x * P + P/2, 
                                  mAnchorY + mHeight - (y * P + P/2), 0 );
                    
                    mSprites[y][x]->draw( 0, 0, &pos, 1, roomTrans );
                    }
                
                }
            }
        }


    if( mHintMode && screenGLStencilBufferSupported ) {
        // use stenciling to draw *shadows* of sprites only

        // don't update color
        glColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );

        // skip fully-transparent areas
        glEnable( GL_ALPHA_TEST );
        glAlphaFunc( GL_GREATER, 0 );
        
        // Draw 1 into the stencil buffer wherever a sprite is
        glEnable( GL_STENCIL_TEST );
        glStencilOp( GL_REPLACE, GL_REPLACE, GL_REPLACE );
        glStencilFunc( GL_ALWAYS, 1, 0xffffffff );
        }
    

    // now draw all sprites
    int numSprites = mObjectSprites.size();
    int selected = mState->getSelectedObject();
    
    if( mLastSelected != selected  || ! mShowGrid ) {
        // reset
        mBlinkCycle = 0;
        mLastSelected = selected;
        }
    else {
        mBlinkCycle ++;
        }

    double blinkFadeFactor = 0.35 * sin( mBlinkCycle / 3.0 ) + 0.65;
    

    //printf( "Drawing %d sprites, %d selected\n", numSprites, selected );
    
    for( int i=0; i<numSprites; i++ ) {
        
        // map index to sort by depth
        int s = *( mDrawOrderMap.getElement( i ) );
        
        

        Sprite *sprite = *( mObjectSprites.getElement( s ) );
        intPair pixelPos = *( mObjectSpritePositions.getElement( s ) );
        int owner = *( mObjectSpriteOwners.getElement( s ) );
        
        Vector3D pos( mAnchorX + pixelPos.x + P/2, 
                      mAnchorY + pixelPos.y + P/2, 0 );
        
        char drawIt = true;
        
        Color c( 1, 1, 1, 1 );
        
        double fadeFactor = *( mObjectSpriteTrans.getElement( s ) );
        
        if( owner != -1 ) {
            // an anchor, override fade
            fadeFactor = 0.5;
            
            if( owner == selected ) {
                fadeFactor *= blinkFadeFactor;
                
                if( owner != 0 ) {
                    // green
                    c.r = 0;
                    c.b = 0;
                    }
                else if( owner == 0 ) {
                    // player's object selected in red
                    c.g = 0;
                    c.b = 0;
                    }
                }
            
            
                
            
            if( !mShowGrid || mHintMode ) {
                // hide anchors
                drawIt = false;
                }
            else if( mState->mLocksOn ) {
                // anchors on... but for this object?
                StateObjectInstance *o = 
                    *( mState->mObjects.getElement( owner ) );
                
                if( o->mLocked ) {
                    drawIt = false;
                    }
                }
            
            
            }
        
        if( drawIt ) {
            char glow = *( mObjectSpriteGlows.getElement( s ) );
            if( glow ) {
                // brighten only
                glBlendFunc( GL_SRC_ALPHA, GL_ONE );
                }

            if( mHintMode ) {
                // override fade
                fadeFactor = 0.25;
                
                // black color
                c.r = 0;
                c.g = 0;
                c.b = 0;
                }
            

            sprite->draw( 0, 0, &pos, 1, fadeFactor, &c );
            
            if( glow ) {
                // back to normal blend
                glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
                }
            }
        }

    if( mHintMode && screenGLStencilBufferSupported ) {
        // stencil buffer has 1 wherever sprite is

        // Re-enable update of color
        glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
        glDisable( GL_ALPHA_TEST );
        
        // Now, only render where stencil is set to 1.
        glStencilFunc( GL_EQUAL, 1, 0xffffffff );  // draw if == 1
        glStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
    
        
        // draw a big dark rectangle, cut out by stenciled areas

        glColor4f( 0, 0, 0, 0.25f ); 
        glBegin( GL_QUADS ); {
            glVertex2d( mAnchorX, mAnchorY );
            glVertex2d( mAnchorX, mAnchorY + mHeight );
            glVertex2d( mAnchorX + mWidth, mAnchorY + mHeight );
            glVertex2d( mAnchorX + mWidth, mAnchorY );
            }
        glEnd();
        

        // draw diagonal yellow hash lines cut out by stenciled areas

        glColor4f( 1, 1, 1, 0.25f ); 
        glBegin( GL_LINES ); {
            
            for( int x=0; x<mWidth; x+=3 ) {
                glVertex2d( mAnchorX + x, mAnchorY );
                glVertex2d( mAnchorX, mAnchorY + x );
                glVertex2d( mAnchorX + x + 2, mAnchorY + mHeight );
                glVertex2d( mAnchorX + mWidth + 2, mAnchorY + x );
                }
            }
        glEnd();
        
        // back to unstenciled drawing
        glDisable( GL_STENCIL_TEST );
        glClear( GL_STENCIL_BUFFER_BIT );
        }
    


    Color *oldFontColor = largeText->getFontColor()->copy();
    largeText->setFontColor( new Color( 0, 0, 0, 1 ) );


    if( ! mHintMode ) {
        
        // draw speech for each object
        int numObjects = mState->mObjects.size();
        
        // put 0's speech on top
        for( int i=1; i<numObjects; i++ ) {
            drawSpeech( i );
            }
        drawSpeech( 0 );
        }
    




    // draw any action text for object 0
    
    StateObjectInstance *o = *( mState->mObjects.getElement( 0 ) );

    if( ! mHintMode &&
        ( strlen( o->mAction ) >  0
          ||
          ( 0 == selected && mEditingAction ) ) ) {
        
        intPair pos = ::add( o->mActionOffset, o->mAnchorPosition );
        
        double height = 8;
        double width = strlen( o->mAction ) * height;
        
        double trueLength = largeText->measureTextWidth( o->mAction ) * height;

        int totalArrowLength = (int)trueLength + 10;
        
        
        double trueStringHeight = height * 
            largeText->measureTextHeight( o->mAction );
        
        char actionTall = false;
        
        if( trueStringHeight > 9 ) {
            // make room for high characters
            actionTall = true;
            }



        // flip anchor if on left side of player
        int flip = 1;
        Sprite *endSprite = mActionBoxEndSprite;
        
        if( o->mActionOffset.x < P/2 ) {
            flip = -1;
            endSprite = mActionBoxEndFlipSprite;
            }
        
        if( flip == 1 && pos.x - totalArrowLength < 0 ) {
            // off left, force flip
            flip = -1;
            endSprite = mActionBoxEndFlipSprite;
            }
        else if( flip == -1 && pos.x + totalArrowLength > P * G - 1 ) {
            // off right, force flip
            flip = 1;
            endSprite = mActionBoxEndSprite;
            }
        
             
        if( actionTall ) {
            if( endSprite == mActionBoxEndSprite ) {
                endSprite = mActionBoxEndTallSprite;
                }
            else {
                endSprite = mActionBoxEndFlipTallSprite;
                }
            }
        


        Vector3D boxPos( mAnchorX + pos.x - flip * 4,
                         mAnchorY + pos.y + 1,
                         0 );
        
        if( flip == -1 ) {
            // nudge
            boxPos.mX += 1;
            }
        
        
        double boxFade = 0.63;
        

        Vector3D boxStartPos = boxPos;

        endSprite->draw( 0, 0, &boxPos, 1, 
                         boxFade );
        
        int trueLengthLeft = (int)trueLength;
        
        // start can contain... 5 pixels?
        //trueLengthLeft -= 7;

        // go a slight bit over to leave extra space at end if it's tight
        // end cap adds to it as well
        while( trueLengthLeft > 14 ) {
            boxPos.mX -= flip * 8;
            
            if( actionTall ) {
                mActionBoxMiddleTallSprite->draw( 0, 0, &boxPos, 1, 
                                                  boxFade );
                }
            else {    
                mActionBoxMiddleSprite->draw( 0, 0, &boxPos, 1, 
                                              boxFade );
                }
            
            trueLengthLeft -= 8;
            }
        
        // now fill in rest, which is less that 8 pixels, with
        // smaller lines
        // sprite is 2 columns wide, but one column is transparent
        // (drawing 1-column-wide sprites, using centered-based drawing,
        //  causes round-off errors)

        // adjust a bit, since tall versions are lopsided
        if( actionTall && flip < 0 ) {
            boxPos.mY += 2;
            }

        char firstExtraLine = true;
        while( trueLengthLeft > 6 ) {
            boxPos.mX -= flip * 1;
            if( firstExtraLine ) {
                // extra offset from center of last full middle segment
                boxPos.mX -= flip * 4;
                firstExtraLine = false;
                }
            
            if( actionTall ) {    
                mActionBoxMiddleExtraTallSprite->draw( 0, 0, &boxPos, flip, 
                                                       boxFade );
                }
            else {
                mActionBoxMiddleExtraSprite->draw( 0, 0, &boxPos, flip, 
                                                   boxFade );
                }
            

            trueLengthLeft -= 1;
            }


        // cap with end

        if( !firstExtraLine ) {
            // used at least one extra line
            boxPos.mX -= flip * 4;
            }
        else {
            // used no extra lines, offst from last full middle segment
            boxPos.mX -= flip * 8;
            }
        
        
        if( actionTall ) {            
            mActionBoxStartTallSprite->draw( 0, 0, &boxPos, flip, 
                                             boxFade );
            }
        else {
            mActionBoxStartSprite->draw( 0, 0, &boxPos, flip, 
                                         boxFade );
            }
        
        
        if( flip == 1 ) {
            boxStartPos = boxPos;
            }
        else {
            // use real start pos, but adjust
            boxStartPos.mX += 7;
            }
        
        // make lower to increase chances of it fitting in box
        char *lowerAction = stringToLowerCase( o->mAction  );
        
        largeText->drawText( lowerAction, 
                             boxStartPos.mX - 4 + 1,
                             boxStartPos.mY - 4,
                             width, height );
        
        delete [] lowerAction;
        }
        
    
    

    // restore
    largeText->setFontColor( oldFontColor );
    
    

    if( mShowGrid && ! mHintMode ) {
        //grid lines
        
        glColor4f( 1, 1, 1, 0.25f ); 
        glBegin( GL_LINES ); {
            
            for( int x=0; x<G+1; x++ ) {
                glVertex2d( mAnchorX + x * P, mAnchorY );
                glVertex2d( mAnchorX + x * P, mAnchorY + mHeight );
                }
            for( int y=0; y<G+1; y++ ) {
                glVertex2d( mAnchorX, mAnchorY + y * P );
                glVertex2d( mAnchorX + mWidth, mAnchorY + y * P );
                }
            }
        glEnd();
        }
    
        
    /*
    // thin white border, partly transparent
    glColor4f( 1, 1, 1, 0.25f ); 
    
    glBegin( GL_LINE_LOOP ); {		
        glVertex2d( mAnchorX, mAnchorY );
        glVertex2d( mAnchorX + mWidth, mAnchorY ); 
        glVertex2d( mAnchorX + mWidth, mAnchorY + mHeight );
            glVertex2d( mAnchorX, mAnchorY + mHeight );
        }
    glEnd();
    */
    

    if( mEditor != NULL ) {
        GameStateEditor *editor = (GameStateEditor *)mEditor;
        
        editor->displayRedrawed();
        }
    
    }



void GameStateDisplay::setLastMouse( double inX, double inY ) {
    mLastPixelClickX = (int)( inX - mAnchorX );
    mLastPixelClickY = (int)( inY - mAnchorY );
    
    mLastGridClickX = (int)( mLastPixelClickX / P );
    mLastGridClickY = (int)( mLastPixelClickY / P );
    
    mLastHoverGridX = mLastGridClickX;
    mLastHoverGridY = mLastGridClickY;
    }



void GameStateDisplay::mouseDragged( double inX, double inY ) {
    if( mHintMode ) return;
    

    mLastActionRelease = false;
    mLastActionPress = false;
    mLastActionKeyPress = false;

    if( isEnabled() && isInside( inX, inY ) ) {
        setLastMouse( inX, inY );
        fireActionPerformed( this );
        }
    }



void GameStateDisplay::mousePressed( double inX, double inY ) {
    if( mHintMode ) return;
    
    mLastActionRelease = false;
    mLastActionPress = true;
    mLastActionKeyPress = false;

    if( isEnabled() && isInside( inX, inY ) ) {
        setLastMouse( inX, inY );
        fireActionPerformed( this );

        // selected object may have changed... update tool tip
        mLastMouseoverObjectIndex = -1;
        
        if( mShowObjectToolTips ) {
            redoToolTip( mLastGridClickX, mLastGridClickY );
            }
        }
    
    }



void GameStateDisplay::mouseReleased( double inX, double inY ) {
    if( mHintMode ) return;
    
    mLastActionRelease = true;
    mLastActionPress = false;
	mLastActionKeyPress = false;
    
    // done dragging with mouse
    mManualBubblePositioningLive = false;
    

    if( isEnabled() && isInside( inX, inY ) ) {
        setLastMouse( inX, inY );
        fireActionPerformed( this );
        }
    }




#include "ToolTipManager.h"
#include "minorGems/util/TranslationManager.h"


void GameStateDisplay::redoToolTip( int inGridX, int inGridY ) {
    int objIndex = mState->getHitObject( inGridX, inGridY );
        
    if( objIndex != -1 ) {
        if( objIndex != mLastMouseoverObjectIndex ) {
                

            StateObjectInstance *objInstance =
                *( mState->mObjects.getElement( objIndex ) );
                
            char *objName = 
                objInstance->mObject.getStateObjectName();
                

            char *tipString;
                
            int selected = mState->getSelectedObject();
                
            char *selectedString = (char *)"";
            if( selected == objIndex ) {
                selectedString = 
                    (char*)
                    TranslationManager::translate( "tip_anchor_selected" );
                }
                

            char *transKey;
            if( objIndex == 0 ) {
                transKey = (char*)"tip_player_anchor";
                }
            else {
                transKey = (char*)"tip_object_anchor";
                }

                
            tipString = autoSprintf( 
                "%s (%s) %s", 
                TranslationManager::translate( transKey ),
                objName,
                selectedString );
                
            delete [] objName;
                
                        
            ToolTipManager::setTip( tipString );
            delete [] tipString;
            }
        }
    else {            
        ToolTipManager::setTip( NULL );
        }

    mLastMouseoverObjectIndex = objIndex;
    }



void GameStateDisplay::mouseMoved( double inX, double inY ) {
    if( mHintMode ) return;
    
    if( isEnabled() && isInside( inX, inY ) ) {

        int pixelX = (int)( inX - mAnchorX );
        int pixelY = (int)( inY - mAnchorY );
    
        int gridX = (int)( pixelX / P );
        int gridY = (int)( pixelY / P );
        
        if( mShowObjectToolTips ) {
            redoToolTip( gridX, gridY );
            }
        
        mMouseHover = true;
        setLastMouse( inX, inY );
        }
    else {
        mMouseHover = false;
        }

    }



void GameStateDisplay::setFocus( char inFocus ) {
    mFocused = inFocus;
    }

char GameStateDisplay::isFocused() {
    return mFocused;
    }


void GameStateDisplay::keyPressed( unsigned char inKey, 
                                   double inX, double inY ) {
    if( mHintMode ) return;

    mLastActionKeyPress = true;
    mLastKeyPressed = inKey;
    
    if( isEnabled() ) {
        fireActionPerformed( this );
        }
    }