/*
 * glass.c
 *
 * Main control section and user interface
 *
 * © 1994-1998 Straylight
 */

/*----- Licensing note ----------------------------------------------------*
 *
 * This file is part of Straylight's Glass.
 *
 * Glass is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * Glass is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Glass.  If not, write to the Free Software Foundation,
 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

/*
 * ANSI standard headers
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <time.h>

#include "dll.h"

/*
 * Steel headers
 */

#define _STDAPP
#define _XFER
#define _LOWLVL
#include "steel/Steel.h"

#include "steel/viewer.h"
#include "steel/mem.h"
#include "steel/caretptr.h"
#include "steel/buttons.h"
#include "steel/sculptrix.h"
#include "steel/flex.h"

/*
 * Glass headers
 */

#include "gStruct.h"
#include "gIcons.h"
#include "gMenus.h"

#include "glass.h"
#include "toolbox.h"
#include "tfile.h"
#include "intMsgs.h"
#include "gPrefs.h"
#include "gSprite.h"
#include "indir.h"
#include "window.h"
#include "tearEdit.h"

/*----- External dependencies ---------------------------------------------*/

extern char date[], cright[];
#define VERSION 100

/*----- Static global variables -------------------------------------------*/

static BOOL glass_genDump;           /* Send timings to dump (stderr)      */
static BOOL glass_noWindow;          /* Turn off the nice intro window     */

/*----- Icon bar handlers -------------------------------------------------*/

/*
 * BOOL glass_unknowns(wimp_eventstr *e,void *handle)
 *
 * Use
 *  Vets unknown events.  The important ones at the moment are
 *  Message_DataOpen and Message_PreQuit.  Glass 1.xx supports the RISC
 *  OS 3 prequit convention to avoid the old misunderstanding.  This may
 *  cause problems under RISC OS 2.  If so, they'll just have to upgrade...
 *
 * Parameters
 *  wimp_eventstr *e == the event in question
 *  void *handle == 0
 *
 * Returns
 *  TRUE if the event has now been processed.
 */

static BOOL glass_unknowns(wimp_eventstr *e,void *handle)
{
  BOOL handled=FALSE;
  int filetype;
  char *filename;
  char buff[256];
  os_regset r;
  unused(handle);
  switch (e->e)
  {
    case wimp_ESEND:
    case wimp_ESENDWANTACK:
      switch (e->data.msg.hdr.action)
      {
        case wimp_MDATAOPEN:
          filetype=xferrecv_checkinsert(&filename);
          switch (filetype)
          {
            case 0xfec:          /* Template file                          */
              xferrecv_insertfileok();
              tfile_loadFromFile(filename,xferrecv_nameToImport());
              handled=TRUE;
              break;
          }
          break;
        case wimp_MPREQUIT:
          if (tfile_okToQuit(TRUE))
            intMsgs_send(glass_KILLFILES);
          else
          {
            e->data.msg.hdr.your_ref=e->data.msg.hdr.my_ref;
            wimpt_noerr(wimp_sendmessage(wimp_EACK,
                                         &e->data.msg,
                                         e->data.msg.hdr.task));
          }
          handled=TRUE;
          break;
        case wimp_MMODECHANGE:
          intMsgs_send(glass_MODECHANGE);
          break;
        case wimp_SAVEDESK:
          sprintf(buff,"Run %s\n",getenv("Glass$Dir"));
          r.r[0]=2;
          r.r[1]=e->data.msg.data.savedesk.filehandle;
          r.r[2]=(int)buff;
          r.r[3]=strlen(buff);
          wimpt_noerr(os_swix(XOS_GBPB,&r));
          handled=TRUE;
          break;
      }
      break;
  }
  return (handled);
}

/*
 * void glass_ibarHandler(ibicon i,ibicon_eventType e,void *handle)
 *
 * Use
 *  Handles events for the icon bar icon (such as help requests, load and
 *  save messages, and of course mouse clicks).
 *
 * Parameters
 *  ibicon i == the handle of the icon
 *  ibicon_eventType e == what has happened
 *  void *handle == a dummy handle
 */

static void glass_ibarHandler(ibicon i,ibicon_eventType e,void *handle)
{
  int filetype;                  /* Filetype of a file to import           */
  char *filename;                /* Filename of a file                     */
  int estsize;                   /* Estimated size of a file to import     */
  void *p;                       /* Pointer to loaded file                 */
  unused(i);                     /* Not actually interested in the icon    */
  unused(handle);                /* Not at all interested in the handle    */
  switch (e)                     /* Find out what's going on               */
  {
    case ibicon_LEFTCLICK:       /* Clicked with select                    */
      {
        glass_tfile *t;
        if (t=tfile_createTemplateFile(msgs_lookup("tfUNT")),t)
          viewer_display(t->v);
      }
      break;
    case ibicon_RIGHTCLICK:      /* Clicked with adjust                    */
      break;                     /* Ignore it and hope it goes away        */
    case ibicon_LOAD:            /* Load request from Filer                */
      filetype=xferrecv_checkinsert(&filename); /* Get information         */
      switch (filetype)
      {
        case 0xfec:              /* Template file                          */
          tfile_loadFromFile(filename,xferrecv_nameToImport());
          xferrecv_insertfileok();
          break;
      }
      break;
    case ibicon_SAVE:            /* Save from another application          */
      filetype=xferrecv_checkimport(&estsize);  /* Get information         */
      switch (filetype)
      {
        case 0xfec:              /* Template file                          */
          if (xferrecv_returnImportedBlock(&p)!=-1)
          {
            tfile_loadFromMemory(&p,xferrecv_nameToImport());
            flex_free(&p);
            flex_compact();
          }
          break;
      }
      break;
    case ibicon_HELP:            /* Help request                           */
      help_startHelp();          /* Start a help reply                     */
      help_addLine(msgs_lookup("wehIB"));
      help_endHelp();            /* Send the message back                  */
      break;
  }
}

/*
 * void glass_ibarMenuHandler(int hit[],void *handle)
 *
 * Use
 *  Processes menu clicks for the icon bar menu.
 *
 * Parameters
 *  int hit[] == array of menu hits
 *  void *handle == 0 (dummy handle)
 */

static void glass_ibarMenuHandler(int hit[],void *handle)
{
  unused(handle);                /* This menu not attached to data struct  */
  switch (hit[0])                /* Check which item was chosen            */
  {
    case glass_IBARINFO:         /* About this program                     */
      progInfo("Glass",
               msgs_lookup("wePUR"),
               cright,
               VERSION,
               date);
      break;
    case glass_IBARPREFS:        /* Preferences dialogue                   */
      gPrefs_edit();            /* Edit the preferences...                */
      break;
    case glass_IBARTBOX:         /* Toolbox (window manipulation)          */
      toolbox();                 /* Handles it all...                      */
      break;
    case glass_IBARHEAPINFO:     /* Heap info display                      */
      indir_heapInfo();          /* Display                                */
      break;
    case glass_IBARQUIT:         /* Quit program                           */
      if (tfile_okToQuit(TRUE))  /* Check the user is sure about this      */
        exit(0);                 /* End Glass and announce success         */
      break;
  }
}

/*
 * void glass_ibarMenuHelp(int hit[],void *handle)
 *
 * Use
 *  Help processor for icon bar menu.
 *
 * Parameters
 *  int hit[] == the item to give help for
 *  void *handle == a dummy handle
 */

static void glass_ibarMenuHelp(int hit[],void *handle)
{
  unused(handle);
  help_startHelp();
  help_readFromMenu("wemhIB",hit);
  help_endHelp();
}

/*----- Initialisation ----------------------------------------------------*/

/*
 * void glass_exit(void)
 *
 * Use
 *  Exit handler, creates internal broadcast to close down everything.
 */

static void glass_exit(void)
{
  intMsgs_send(glass_CLOSEDOWN);
}

/*
 * void glass_iconbar(void)
 *
 * Use
 *  Sets up the icon bar during Glass initialisation.  Essentially, it
 *  installs an icon bar, attaches a menu to it, and gives it a handler.
 *  It also establishes a handler for loading and mouse clicks.
 */

static void glass_iconbar(void)
{
  ibicon i;                      /* Handle for the icon we will create     */
  menu m;                        /* The menu to attach to the icon         */
  m=menu_new("Glass",msgs_lookup("weIBM"));
  i=ibicon_create(ibicon_RIGHT,"!glass",ibicon_WIMPAREA,0,0);
  ibicon_attachMenu(i,m,glass_ibarMenuHandler,glass_ibarMenuHelp,0);
  ibicon_eventHandler(i,glass_ibarHandler,0);
}

/*
 * void glass_scanCLI(int argc,char *argv[],BOOL inited)
 *
 * Use
 *  Scans command line string and loads relevant files
 *
 * Parameters
 *  int argc == the number of words in the string
 *  char *argv[] == the words, as an array of strings
 *  BOOL inited == whether we have initialised the WIMP
 */

static void glass_scanCLI(int argc,char *argv[],BOOL inited)
{
  int i;
  for (i=1;i<argc;i++)
  {
    if (utils_caselessCmp(argv[i],"-genDump")==0)
      glass_genDump=TRUE;
    else if (utils_caselessCmp(argv[i],"-noWindow")==0)
      glass_noWindow=TRUE;
    else if (utils_caselessCmp(argv[i],"-help")==0)
    {
      printf
      (
        "Glass %i.%02i (%s)\n"
        "\n"
        "%s"
        "\n"
        "Command line syntax:\n"
        "  Glass [<option> | <filename>]...\n"
        "\n"
        "<filename> == file name to load\n"
        "<option> is one of:\n"
        "  -help == display this help\n"
        "  -genDump == dump timings and other crap to stderr\n"
        "  -noWindow == don't display startup window\n",
        VERSION / 100,
        VERSION % 100,
        date, cright
      );
      exit(0);
    }
    else
    {
      if (inited)
        tfile_loadFromFile(argv[i],argv[i]);
    }
  }
}

/*
 * void glass_wait(int cs)
 *
 * Use
 *  Makes everything stand still for a bit
 *
 * Parameters
 *  in cs == number of centiseconds to wait
 */

static void glass_wait(int cs)
{
  int waiting;
  os_regset r;
  wimpt_noerr(os_swix(XOS_ReadMonotonicTime,&r)); /* Now wait for a bit    */
  waiting=r.r[0];
  while (r.r[0]-waiting<cs)      /* Half a second should do...             */
    wimpt_noerr(os_swix(XOS_ReadMonotonicTime,&r)); /* Get the time again  */
}

/*
 * void glass_initProgress(dbox d,char *message,int percent)
 *
 * Use
 *  Updates the display on the loading window while we;re initialising
 *  everything.
 *
 * Parameters
 *  dbox d == the dbox being used
 *  char *message == the message to display in the little icon.  A null
 *    pointer indicates that the message is not to change.
 *  int percent == the percentage complete so far
 */

static void glass_initProgress(dbox d,char *message,int percent)
{
  static dbox dd;
  if (!dd)
    dd=d;
  else if (!d)
    d=dd;
  if (d)
  {
    buttons_updateSlider(d,glass_CRSLIDER,100,percent,8,FALSE);
    dbox_setfield(d,glass_CRPERCENT,"%i",percent);
    if (message)
      dbox_setfield(d,glass_CRDOING,"%s",message);
  }
  else
    visdelay_percent(percent);
  if (glass_genDump)
  {
    fprintf(stderr,
            "Glass init timing: %s - %i\n",
            message ? message : "ditto",
            clock());
  }
}

/*
 * void glass_initialise(int argc,char *argv[])
 *
 * Use
 *  Does all the tedious initialisation procedure, and the bit with the
 *  intro window.
 *
 * Parameters
 *  int argc == the number of words in the CLI string
 *  char *argv[] == the words, as an array of strings
 */

static void glass_initialise(int argc,char *argv[])
{
  sprite_area *a=0;
  os_regset r;
  dbox d=0;
  wimp_redrawstr rdr;
  BOOL more;

  _dll_setname("Glass");

  glass_scanCLI(argc,argv,FALSE); /* Scan command line arguments           */
  visdelay_begin();              /* Turn on the hourglass immediately      */

  /* --- Set up STEEL's options --- *
   *
   * We need to enable all the external module support, because we need
   * to handle templates written to use them.  The non-WIMP shading is just
   * a nice touch.
   */

#ifdef glass_DEBUGGING
  #define _options \
    wimpt_OSCULPTRIX | \
    wimpt_OINTERFACE | \
    wimpt_OWIMPEXT | \
    wimpt_ONOWIMPSHADE | \
    wimpt_OREMSAVEICON
#else
  #define _options \
    wimpt_OSCULPTRIX | \
    wimpt_OINTERFACE | \
    wimpt_OWIMPEXT | \
    wimpt_ONOWIMPSHADE | \
    wimpt_OREMSAVEICON | \
    wimpt_ONOBACKTRACE
#endif

  wimpt_setOptions(_options,_options);

  wimpt_init("Glass");           /* Crank up the WIMP                      */
  res_init("Glass");             /* Point to resource files                */
  mem_flexdInit(0, 0);        /* Initialise flex system                 */

  resspr_init();                 /* Load my copious quantities of sprites  */
  if (!glass_noWindow)
  {
    template_readfile(res_name("LoadTpl"));

    r.r[0]=17;                   /* Need to find the size of banner sprite */
    r.r[1]=(int)res_name("LoadSpr"); /* Set up name                        */
    wimpt_noerr(os_swix(XOS_File,&r)); /* Do the call                      */
    if (!flex_alloc((flex_ptr)&a,r.r[4]+4))  /* Allocate memory for sprites*/
      a=0;                       /* If failed, don't show sprites          */
    else
    {
      sprite_area_initialise(a,r.r[4]+4); /* Initialise sprite area (!)    */
      wimpt_noerr(sprite_area_load(a,res_name("LoadSpr")));
                                 /* Do the load as required                */
      template_syshandle("loading")->spritearea=a; /* Rig sprite area      */
    }
    if (d=dbox_create("loading"),d) /* Create the dialogue box             */
    {
      dbox_setfield(d,
                    glass_CRVERSION,
                    "%i.%02i (%s)",
                    VERSION/100,
                    VERSION%100,
                    date);
      dbox_setfield(d, glass_CRGPLNOTE,
                    "Glass is free software; it may be modified and/or "
                    "redistributed under the terms of the GNU General "
                    "Public License.");
      dbox_setfield(d, glass_CRNOWARRANTY,
                    "Glass is distributed in the hope that it will be "
                    "useful, but WITHOUT ANY WARRANTY.");
      dbox_display(d,dbox_STATIC_CENTRE); /* Display                       */
      rdr.w=dbox_syshandle(d);     /* Draw the window on the screen NOW    */
      wimpt_noerr(wimp_redraw_wind(&rdr,&more)); /* Start redraw process   */
      while (more)                 /* Carry on till it's all done          */
      {
        wimpt_noerr(sculptrix_redrawWindow(&rdr)); /* Do the 3D bitties    */
        buttons_redrawSlider(d,glass_CRSLIDER,100,0,8,FALSE);    /* Slider */
        wimpt_noerr(wimp_get_rectangle(&rdr,&more)); /* Get the next bit   */
      }
    }
    else
      visdelay_percent(0);         /* If no box, give percentage, at least */

    if (a)
    {
      flex_free((flex_ptr)&a);
      flex_compact();
    }
  }
  else
    visdelay_percent(0);           /* If no box, give percentage, at least */

  glass_initProgress(d,msgs_lookup("weILM:Loading messages"),0);
  msgs_init();                   /* Read messages file (for help messages) */

  glass_initProgress(d,msgs_lookup("weILW"),15);
  template_init();
  werr_init();                   /* Load nice error box                    */

  glass_initProgress(d,msgs_lookup("weLDF"),43);
  gSprite_init();
  window_init();
  tearEdit_init();

  glass_iconbar();               /* Set up the icon bar appropriately      */

  glass_initProgress(d,msgs_lookup("weIRP"),53);
  gPrefs_init();

  caretPtr("ptr_caret",resspr_area(),4,5); /* Enable pointer change        */
  win_add_unknown_event_processor(glass_unknowns,0);    /* OPEN, PREQUIT   */
  event_returnMenuHelp(TRUE);

  glass_initProgress(d,msgs_lookup("weILD"),61);
  indir_init();
  glass_scanCLI(argc,argv,TRUE);    /* Scan command line arguments again   */
  if (d)
    dbox_display(d,dbox_STATIC_LASTPOS);
  atexit(glass_exit);            /* Exit handler to free up fonts          */

  if (d)
  {
    glass_initProgress(d,msgs_lookup("weIFI"),100);
    glass_wait(50);
    dbox_delete(d);
  }

  visdelay_end();                /* Finished initialisation                */
}

/*
 * int main(int argc,char *argv[])
 *
 * Use
 *  Control initially passed to this routine.  It essentially sets up all
 *  initial handlers (the icon bar etc.) and lets the event system handle
 *  the rest.
 *
 * Parameters
 *  int argc == the number of command line arguments passed
 *  char *argv == an array of command line arguments
 *
 * Returns
 *  zero == successful completion
 *  nonzero == abnormal termination
 *
 *  Defined return codes are:
 */

int main(int argc,char *argv[])
{
  exception_handler e;           /* Point to return to on an exception     */
  glass_initialise(argc,argv);   /* Perform necessary initialisation       */
  visdelay_begin();              /* Display hourglass between polls        */
  (void)exception_registerHandler(e); /* Return here if anything goes amiss*/
  mem_useMalloc();               /* Ensure use of standard heap            */
  for(;;)                        /* And now, just process events until...  */
    event_process();             /* ...kingdom come.                       */
  return (0);                    /* Return successfully                    */
}