#include <adv3.h>

#include <en_us.h>

  /*

   *    Custom Banner version 1.2

   *     by Eric Eve

   *  

   *     Version date: 13-Sep-06

   *

   *     This file implements a CustomBannerWindow class that vastly eases

   *     the process of setting up banners and displaying material in them.

   *     e.g. to set up a graphics banner to display pictures, starting with

   *     pic1.jpg at startup, but not appearing at all on an interpreter that

   *     can't display JPEGs you could define:

   *

   *     pictureWindow: CustomBanner

   *       canDisplay = (systemInfo(SysInfoJpeg))

   *       bannerArgs = [nil, BannerAfter,  statuslineBanner, BannerTypeText, 

   *             BannerAlignTop, 10, BannerSizeAbsolute, BannerStyleBorder]

   *       currentContents = '<img src="pic1.jpg">'

   *    ;

   *

   *    Then to change the picture dislayed at a later point, call:

   *

   *       pictureWindow.updateContents('<img src="pic2.jpg">');

   *

   *    And everything else, including getting everything right on RESTART, UNDO

   *    and RESTORE should be taken care of.

   */

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

  /* 

   *  A CustomBannerWindow, like a BannerWindow, corrsponds to an on-screen

   *  banner. The purpose of CustomBannerWindow is to eliminate most of the

   *  busy-work that a game author would otherwise have to take care of in

   *  displaying and manipulating banners.

   *

   *  As with BannerWinnow, merely creating a CustomBannerWindow does not

   *  display the banner. However, any CustomBannerWindows in existence at

   *  the start of the game will be added to the screen display, unless the

   *  condition specified in their shouldDisplay() method prevents initialization.

   *

   *  The one property that must be defined on each instance of a CustomBannerWindow

   *  is bannerArgs, which takes the form:

   *

   *     bannerArgs = [parent, where, other, windowType, align, 

   *                     size, sizeUnits, styleFlags]

   *

   *  where each list element has the same meaning at the corresponding argument

   *  to BannerWindow.showBanner()

   *

   *  This merely ensures that the CustomBannerWindow is added to the screen's

   *  banner window layout. To have the CustomBannerWindow display some content

   *  when first added to the screen layout, override its current contents property:

   *

   *     currentContents = 'My initial contents'

   *

   *  To change what's displayed in a CustomBannerWindow from game code, call its

   *  updateContents() method, e.g.:

   *

   *     pictureWindow.updateContents('<img src="pics/troll.jpg">');

   *

   *  To redisplay the current contents, call the showCurrentContents() method.

   *  By default a call to updateContents() or showCurrentContents() clears the

   *  window before displaying the new content. To have the additional content

   *  added to the existing content, change the clearBeforeUpdate property to nil.

   *

   *  You can control whether the game uses this banner at all by overriding

   *  the canDisplay property. The main purpose of this property is to easily allow

   *  a game to run on different types of interpreter. For example, if your banner is

   *  meant to display pictures in the JPEG format, there's no point having it included

   *  in the screen layout of an interpreter that can't display JPEGs, and attempts to

   *  update its contents with a new picture should do nothing. In which case we could

   *  define:

   *

   *     canDisplay = (systemInfo(SysInfoJpeg))

   *

   *  Calls to CustomBannerWindow methods like updateContents() and clearWindow()

   *  should be safe on an interpreter for which shouldDisplay returns nil, since

   *  by default these will do nothing beyond updating the banner's currentContents

   *  property. This makes it easier to write game code that is suitable for all 

   *  classes of interpreter

   *

   *  To have a CustomBannerWindow resize to contents each time its contents are

   *  displayed, set its autoSize property to true.   

   *

   *  If you do not want a CustomBannerWindow you have defined not to be dispayed

   *  at game startup, set its isActive property to nil. Call the activate()

   *  method to add it to the screen layout and the deactivate() method to remove

   *  it, or any other CustomBannerWindow, from the screen display.    

   *    

   *  Obviously, it is then the game author's responsibility to ensure that no

   *  other banner window that's meant to persist after pictureWindow is deactivated

   *  depends on pictureWindow for its existence; i.e. that we're not deactivating

   *  the parent of some other banner window(s) we want to keep or subsequently

   *  activate, or the sibling of any banner window that's subsequently going to

   *  defined in relation to us.    

   */

class CustomBannerWindow: BannerWindow

 /*

  *  The list of any banner windows that must be set up before me,

  *  either one of them is my parent, or because I'm going

  *  to be placed before or after them with BannerBefore or BannerAfter.

  *

  *  If bannerArgs has been set up with the list of showBanner arguments, 

  *  then we can derive this information automatically

  */

  initBeforeMe()

  {

    /*

     *  If our bannerArgs property contains a list of the right length, i.e. 8

     *  elements, then the first and third elements of the list (our parent, and

     *  the sibling we're to be placed before or after) must be initialized before

     *  we are. If either of these is nil, no harm is done, since initBannerWindow()

     *  will simply skip the nil value.     

     *

     *  Moreover, if our sibling is in the list, we don't need our parent as well,

     *  since either our sibling or one of its siblings will initialize our parent.

     */

    local lst = [];

    if (propType(&bannerArgs) == TypeList && bannerArgs.length() == 8) 

      lst = bannerArgs[3] ? [bannerArgs[3]] : [bannerArgs[1]];

    initBeforeMe = lst;

    return lst;    

  }   

  /*

   * A condition to test whether this banner window should actually display.

   * Normally this would test for the interpreter class if this would

   * affect whether we wanted this banner to be created. For example, if

   * we were going to use this banner window to display a JPEG picture, we

   * might not this window to display at all if the interpreter we're running

   * on can't display JPEGS, so we might write:

   *

   *    canDisplay = (systemInfo(SysInfoJpeg))

   *

   *   If your complete system of CustomBanners depends on the same condition

   *   (e.g. you don't want any CustomBanners if the interpreter we're running

   *   on can't display JPEGs, then it's probably easiest to modify CustomBanner

   *   and override scanDisplay on the modified class.

   *

   *  By default, we simply check that the interpreter we're running on

   *  can display banners.

   */

  canDisplay = (systemInfo(SysInfoBanners))  

  shouldDisplay = (canDisplay && isActive)

   /*

    *  The standard use of initBannerWindow is first to ensure that any

    *  banner windows whose existence we presuppose have themselves been

    *  initialized, and then to set up our own window on screen.

    *  This function should be used for initializing banner window *layout*,

    *  not content.

    */

  initBannerWindow()

  {

     /*

      *  If we shouldn't display on this class of interpreter, don't

      *  initialize us.

      */

     if(!shouldDisplay)

       return nil;

     /*

      *  If we've already been initialized, there's nothing left to do.

      */

     if(inited_)

       return true;  

     /*  

      *  Initialize all the bannner windows on whose existence our own

      *  depends. If one of them can't be initialized, neither can we,

      *  in which case return nil to show that our initialization failed. 

      *  If, however, the parent or sibling banner window we want initialized

      *  before us is not a CustomBannerWindow, then its initBannerWindow()

      *  won't have a return value, in which case we ignore the fact that

      *  it returns nil 

      */

     foreach(local ban in initBeforeMe)

       if(ban && !ban.initBannerWindow() && ban.ofKind(CustomBannerWindow))

         return nil;

     /*  

      * Create my banner window on screen; if this fails return nil

      * to indicate that the window could not be created

      */       

      return (inited_ = initBannerLayout());

  }

  /*

   *  Initialize my onscreen layout, normally through a call to showBanner(),

   *  whose return value this method should return, e.g.:

   *

   *     initBannerLayout()

   *     {

   *         return showBanner(nil, BannerAfter,  statuslineBanner,

   *           BannerTypeText, BannerAlignTop, 1, BannerSizeAbsolute,

   *           BannerStyleBorder); 

   *     }

   *

   *    By default we simply call initBannerLayout() using our bannerArgs.

   */

  initBannerLayout()

  {

     return showBanner(bannerArgs...);

  }

  /* 

   * The list of args used to define our screen layout, as they would be passed

   * to showBanner. This is used both by initBannerLayout and initBeforeMe.

   *

   *  The args should be listed in the form

   *

   *  bannerArgs = [parent, where, other, windowType, align, size, sizeUnits, styleFlags]

   *

   *  e.g.

   *    bannerArgs = [nil, BannerAfter,  statuslineBanner,

   *           BannerTypeText, BannerAlignTop, 1, BannerSizeAbsolute,

   *           BannerStyleBorder]

   *   

   */

  bannerArgs = nil

  /*

   *  The current contents to be displayed in this window, which could be 

   *  a string of text, or the HTML string to display a picture.

   *

   *  currentContents can be overridden to hold the initial contents

   *  we want this banner to display, but it should not otherwise be

   *  directly written to in game code. To display new contents in the

   *  banner, use updateContents() instead.  

   */

  currentContents = ''

  /*

   *  Is this banner currently active? Set to nil if you don't want to this

   *  CustomBannerWindow to be active at startup; thereafter use the deactivate()

   *  and activate() methods   

   */

  isActive = true

  /*

   *  deactivate a currently active banner; this removes it from the screen

   *  and prevents writing anything further to it. Be careful to respect the

   *  dependency order of banner windows when activating and deactivating

   *

   *  The argument is optional. If it is the constant true then the currentContents

   *  will be set to an empty string (''). If it is a string, then the currentContents

   *  will be set to that string (ready to be displayed when the banner is reactivated).

   */

  deactivate([args])  

  {     

     removeBanner();

     isActive = nil;

     if(args.length > 0)

     {

        local arg = args[1];

        switch(dataType(arg))

        {

           case TypeTrue:

             currentContents = '';

             break;

           case TypeSString:

             currentContents = arg;

             break;

        }

     }

  }

  /* 

   *  Activate a currently inactive banner; this restores it to the screen. 

   *  The argument is optional; if present and true then activate(true)

   *  displays the current contents of the banner window after activating it.

   *  If the first argument is a string then the string is displayed in the banner.   

   */ 

  activate([args])

  {

      if(isActive)

         return;

      isActive = true;

      initBannerWindow();

      if(args.length() > 0 && args[1] != nil)

      {

         if(dataType(args[1]) == TypeSString)

            updateContents(args...);

         else  

            showCurrentContents();

      }

  }

  removeBanner()

  {

    /*

     *  If I'm removed I can't be inited_ any more, and I'll need to be regarded

     *  as not inited_ in the event of being redisplayed in the future.

     */

    inited_ = nil;

    inherited;

  } 

  /*

   * Set this flag to true to clear the contents of the window before displaying

   * the new contents, e.g. to display a new picture that replaces the old one.

   */

  clearBeforeUpdate =  true

  /* 

   *  Set this to true to have this banner size to contents each time its

   *  contents are displayed. Note that not all interpreters support the size to

   *  contents so you should still set an appropriate initial size, and, where

   *  appropriate, call setSize() with the isAdvisory flag set.

   */

  autoSize = nil

  /*

   *  Update the contents of this banner window. This is the method to

   *  call to change what a banner displays.   

   *

   *  The second argument is optional. If present it overrides the 

   *  setting of clearBeforeUpdate: updateContents(cont, true) will

   *  clear the banner before the update, whereas updateContents(cont, nil)

   *  will not, whatever the value of clearBeforeUpdate. 

   */

  updateContents(cont, [args])

  {

    /*

     *  Update our current contents. Note that this takes place even if

     *  shouldDisplay is nil, so that if, for example, we are updated on

     *  a text-only interpreter on which this banner is not displayed, 

     *  and the game is saved there and subsequently restored on a full HTML 

     *  interpreter in which we are displayed, the HTML interpreter will know 

     *  what contents it needs to display in us.

     */

    currentContents = cont;

    showCurrentContents(args...);

  }

  /* Show the current contents of this banner window */  

  showCurrentContents([args])

  { 

    local clr;

    if(args.length > 0)

      clr = (args[1] != nil);

    else

      clr = clearBeforeUpdate;

    if(clr)    

       clearWindow();

     writeToBanner(currentContents);      

     if(autoSize)

       sizeToContents();

  }

   /*  This is called on each CustomBannerWindow after a Restore. */   

  restoreBannerDisplay()

  {

        /* 

         * It's possible a game was saved in a text-mode terp and

         * restored in an HTML one. In which case we need to initialize

         * this banner before attempting to display anything

         */

         if(shouldDisplay && handle_ == nil)

         {

            if(!initBannerWindow())

              return;

         }

        /* redisplay my contents after a restore */        

        showCurrentContents(); 

  }  

  /*

   *  Alternatively we might have been saved in a terp that does

   *  use this banner and restored in one that doesn't, in which

   *  case we should remove ourselves. This is called on each BannerWindow

   *  after a restore, but before bannerTracker.restoreDisplayState().

   */

  restoreRemove()

  {

     if(!shouldDisplay)        

        removeBanner();     

  }

  /* show my initial contents on startup */

  initBannerDisplay()  {  showCurrentContents();   }

  /*

   *   We provide overrides for all the various banner manipulation methods

   *   that game code might call, in order to make it safe to call them even

   *   our shouldDisplay method returns nil and we don't - or shouldn't - exist.

   *   For each of these xxxYyy methods we provide an altXxxyyy method that is

   *   called when shouldDisplay is nil (e.g. because we're using a window to

   *   display graphics on an interpreter that doesn't have graphics capablities).

   *   By default these altXxxYyy methods do nothing, which in many cases will

   *   be fine, but if you do want something else to happen you can override

   *   the appropriate altXxxYyy method accordingly (e.g. to show a message in

   *   the main game window instead of this banner). This should make it easier

   *   to structure the rest of your game code without needing to worry about

   *   what happens on interpreters which don't display your banners.

   */

  clearWindow()

  {

    if(shouldDisplay)

      inherited();

    else

      altClearWindow();

  }

  altClearWindow() { }

  /* write to me, but only if I should display */ 

  writeToBanner(txt)

  {  

    if(shouldDisplay)

      inherited(txt);

    else

      altWriteToBanner(txt);

  }

  /*

   *  altWriteToBanner(txt) is called when our game code tries to display

   *  something in this banner, but our shouldDisplay method has ruled out

   *  displaying this banner. In this case we might want to write something

   *  to the main display instead. By default we do nothing here, but

   *  individual instances and/or subclasses can override this method as

   *  required.

   */

  altWriteToBanner(txt) { }

  /* 

   *  We don't provide alternative methods for the setSize and sizeToContents

   *  methods, since there would almost certainly be nothing for them to do.

   *  We simply do nothing if shouldDisplay is nil.

   */

  setSize(size, sizeUnits, isAdvisory)

  {

       if(shouldDisplay)

         inherited(size, sizeUnits, isAdvisory);

  }

  sizeToContents()

  {

        /* size our system-level window to our contents */

       if(shouldDisplay)  

         bannerSizeToContents(handle_);

  }

  captureOutput(func)

  {

     if(shouldDisplay)

       inherited(func);

     else

       altCaptureOutput(func);  

  }

  /* Simply execute the callback without changing the output stream */

  altCaptureOutput(func) { (func)(); }

  setOutputStream()

     {

        if(shouldDisplay)

           /* set my stream as the default */

           return outputManager.setOutputStream(outputStream_);

        else

           return altSetOutputStream();          

     }

  /* 

   *  Our caller, or rather our caller's caller, will expect us to return

   *  the current output stream, which means we must be sure to do this

   *  whatever else we do.  

   */

  altSetOutputStream() { return outputManager.curOutputStream; }         

  flushBanner() 

  { 

    if(shouldDisplay)

      inherited();

    else  

      altFlushBanner();

  }

  altFlushBanner() { }       

  setTextColor(fg, bg)

  {

    if(shouldDisplay)

      inherited(fg, bg);

    else

      altSetTextColor(fg, bg);

  }         

  altSetTextColor(fg, bg) { }

  setScreenColor(color)

  {

    if(shouldDisplay)

      inherited(color);

    else

      altSetScreenColor(color);

  }

  altSetScreenColor(color) { }

  cursorTo(row, col)

  {

    if(shouldDisplay)

      inherited(row, col);

    else

      altCursorTo(row, col);

  }             

  /* 

   *  If this banner isn't displaying we can't do anything directly comparable

   *  to setting the cursot to a particular column and row in it, but we might

   *  want to do something else instead, like inserting so many blank lines in 

   *  the main window.            

   */       

  altCursorTo(row, col) { }         

;

 /*

  *  Initialize or reinitialize what all CustomBanners display at startup or

  *  after an UNDO

  */

customBannerInit: InitObject, PostUndoObject

  execBeforeMe =  [bannerInit]

  execute()

  {

     /* first ensure that all banner windows that need to exist do exist */

//     forEachInstance(CustomBannerWindow, new function(win) {

//        if(win.shouldDisplay && win.handle_ == nil)

//          win.initBannerWindow(); 

//     } );

     /* then show the current contents of every active banner */

     forEachInstance(CustomBannerWindow, {win: win.showCurrentContents() } );

  }

;

  /*

   *  Reinitialize what all the CustomBanners display on restoring. This requires

   *  a different procedure since we can't be sure that we're being restored on

   *  the same class of interpreter as we were saved on.

   */

customBannerRestore: PostRestoreObject

   execBeforeMe = [bannerTracker] 

   execute()

   {

     /*

      *  If we save in one terp, restore in the second terp, save in the second

      *  terp, then restore in the first terp, when different rules apply about

      *  displaying banners in the two terps, then windows removed in the second

      *  terp could still be marked as inited_ in the restore file that comes

      *  back to the first terp. To get round this, on restoration we ensure

      *  that each CustomBanner's inited_ property in fact corresponds to whether

      *  it has an active handle_, otherwise the attempt to reinitialize missing

      *  banners might fail.

      */

     forEachInstance(CustomBannerWindow, {win: win.inited_ = (win.handle_ != nil) } );

     forEachInstance(CustomBannerWindow, {win: win.restoreBannerDisplay() } );

   }

;

customBannerRestoreRemove: PostRestoreObject

  execAfterMe = [bannerTracker]

  execute()

  {

      forEachInstance(CustomBannerWindow, {win: win.restoreRemove() } );

  }

;

 /*

  *  If we display a menu then we need to remove any active banners from the

  *  screen before the menu displays and restore them to the screen on exiting

  *  from the menu

  */

modify MenuItem

  display()

  {

    /*

     *  First we store a list of all the banners that are currently

     *  displaying

     */

    local vec = new Vector(10);

    forEachInstance(CustomBannerWindow, new function(ban) {

        if(ban.shouldDisplay)

          vec.append(ban);  } );    

    /* deactive all active banners */      

    foreach(local ban in vec)

       ban.deactivate();

    try

    {

       /* carry out the inherited menu display */

       inherited();

    }  

   /* 

    *  Restore all the banners in our list of banners that were previously

    *  displayed. To ensure that they are activated in the right order

    *  we make what may be several passes through the list. On each pass

    *  we activate only those banners that don't depend on any inactive

    *  banners for their activation. Each time we activate a banner, we

    *  remove it from the list. On the next pass through the list any

    *  banners that depended on banners we have just activated may now themselves

    *  be activated, so we can carry on until every banner has been activated

    *  and removed from the list.  

    */  

   finally

   {

     while(vec.length())

     {

       local bannerRemoved = nil;

       foreach(local ban in vec)

       {

         if(ban.bannerArgs[1] != nil && ban.bannerArgs[1].handle_ == nil)

            continue;

         if(ban.bannerArgs[3] != nil && ban.bannerArgs[3].handle_ == nil)

            continue; 

         ban.activate(true);

         vec.removeElement(ban);

         bannerRemoved = true;      

       }  

       /*

        *  If we didn't remove any banners on this pass through, we're

        *  potentially in an infinite loop, so we'd better break out

        *  of it.

        */

       if(!bannerRemoved)

         break;

     }

    }            

  }

;