OpenURL

/* Copyright 1997 Acorn Computers Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/***************************************************/
/* File   : OpenURL.c                              */
/*                                                 */
/* Purpose: Functions relating to the Open URL     */
/*          dialogue box.                          */
/*                                                 */
/* Author : A.D.Hodgkinson                         */
/*                                                 */
/* History: 17-Apr-97: Created.                    */
/***************************************************/

#include <stdlib.h>
#include <string.h>

#include "swis.h"

#include "HTMLLib.h" /* HTML library API, Which will include html2_ext.h, tags.h and struct.h */

#include "wimp.h"
#include "wimplib.h"
#include "event.h"

#include "toolbox.h"
#include "window.h"

#include "svcprint.h"
#include "Global.h"
#include "FromROSLib.h"
#include "MiscDefs.h"
#include "Utils.h"

#include "Browser.h"
#include "Fetch.h" /* (For ISLINK macro) */
#include "FetchPage.h"
#include "History.h"
#include "Hotlist.h"
#include "Menus.h"
#include "URLutils.h"
#include "Windows.h"

#include "OpenURL.h"

/* Local structures */

typedef struct openurl_contents
{
  char         url[Limits_URLBarWrit];

  /* Where to open the URL to */

  unsigned int in_this   :1;
  unsigned int save_link :1;
  unsigned int in_new    :1;
  unsigned int in_parent :1;

} openurl_contents;

/* Local statics */

// We *really* want to be mallocing this...
static openurl_contents   contents;        /* Remember the old dialogue contents so the Cancel button can work */

static ObjectId           window_id   = 0; /* Remember the ID in case it needs closing 'out of the blue'. */
static ObjectId           ancestor_id = 0; /* Remember the ancestor ID in case the ancestor closes. */

static HStream          * open_hst = NULL; /* See openurl_to_show_from_menu */

/* Static function prototypes */

static _kernel_oserror * openurl_read_contents   (ObjectId dialogue, openurl_contents * contents);
static _kernel_oserror * openurl_set_contents    (ObjectId dialogue, openurl_contents * contents);

static int               openurl_ok              (int eventcode, ToolboxEvent * event, IdBlock * idb, void * handle);
static int               openurl_cancel          (int eventcode, ToolboxEvent * event, IdBlock * idb, void * handle);
static int               openurl_radio_group_one (int eventcode, ToolboxEvent * event, IdBlock * idb, void * handle);
static int               openurl_click           (int eventcode, WimpPollBlock * b, IdBlock * idb, void * handle);
static int               openurl_key_handler     (int eventcode, WimpPollBlock * b, IdBlock * idb, void * handle);

/*************************************************/
/* openurl_read_contents()                       */
/*                                               */
/* Reads the contents of the Open URL dialogue   */
/* into an openurl_contents structure.           */
/*                                               */
/* Parameters: Object ID of the dialogue;        */
/*                                               */
/*             Pointer to the structure to write */
/*             to.                               */
/*************************************************/

static _kernel_oserror * openurl_read_contents(ObjectId dialogue, openurl_contents * contents)
{
  _kernel_oserror * e;
  int               state;

  /* Read the URL string */

  *contents->url = 0;

  e = writablefield_get_value(0,
                              dialogue,
                              OpenWrit,
                              contents->url,
                              sizeof(contents->url),
                              NULL);

  contents->url[sizeof(contents->url) - 1] = 0; /* (Ensure termination) */

  if (e) return e;

  /* Read radio group 1 - where to open the URL */

  RetError(radiobutton_get_state(0, dialogue, OpenInThis,   &state, NULL)); contents->in_this   = !!state;
  RetError(radiobutton_get_state(0, dialogue, OpenSaveLink, &state, NULL)); contents->save_link = !!state;
  RetError(radiobutton_get_state(0, dialogue, OpenInNew,    &state, NULL)); contents->in_new    = !!state;
  RetError(radiobutton_get_state(0, dialogue, OpenInParent, &state, NULL)); contents->in_parent = !!state;

  /* Finished */

  return NULL;
}

/*************************************************/
/* openurl_set_contents()                        */
/*                                               */
/* Sets the contents of the Open URL dialogue    */
/* from an openurl_contents structure.           */
/*                                               */
/* Parameters: Object ID of the dialogue;        */
/*                                               */
/*             Pointer to the structure to read  */
/*             from.                             */
/*************************************************/

static _kernel_oserror * openurl_set_contents(ObjectId dialogue, openurl_contents * contents)
{
  /* The URL entry field */

  RetError(writablefield_set_value(0,
                                   dialogue,
                                   OpenWrit,
                                   contents->url));

  /* Radio group 1 - where to open the URL */

  RetError(radiobutton_set_state(0, dialogue, OpenInThis,   contents->in_this));
  RetError(radiobutton_set_state(0, dialogue, OpenSaveLink, contents->save_link));
  RetError(radiobutton_set_state(0, dialogue, OpenInNew,    contents->in_new));
  return   radiobutton_set_state(0, dialogue, OpenInParent, contents->in_parent);
}

/*************************************************/
/* openurl_fill_in_url()                         */
/*                                               */
/* If an external function wants to set the URL  */
/* in the writable field of the Open URL         */
/* dialogue, this is the function to use.        */
/*                                               */
/* Parameters: Pointer to the null terminated    */
/*             URL string.                       */
/*************************************************/

_kernel_oserror * openurl_fill_in_url(char * url)
{
  if (!url || !window_id) return NULL;

  return writablefield_set_value(0,
                                 window_id,
                                 OpenWrit,
                                 url);
}

/*************************************************/
/* openurl_to_be_shown()                         */
/*                                               */
/* Called when the EOpenToBeShownMisc event is   */
/* generated, typically when the Open URL window */
/* is about to be shown. Handles any icon        */
/* processing commands in the writable,          */
/* registers event handlers, etc.                */
/*                                               */
/* Parameters are as standard for a Toolbox      */
/* event handler.                                */
/*************************************************/

int openurl_to_be_shown(int eventcode, ToolboxEvent * event, IdBlock * idb, void * handle)
{
  char text[Limits_URLBarWrit];

  /* In multiuser builds, must be logged in... */

  #ifndef SINGLE_USER

    if (!logged_in)
    {
      toolbox_hide_object(0, idb->self_id);
      return 1;
    }

  #endif

  /* If the stored dialogue ID is non-zero on entry, the dialogue */
  /* was reopened without closing - so get rid of the various     */
  /* event handlers before we reregister them.                    */

  if (window_id) openurl_close(0, 1);

  /* Read the window ID and ancestor ID from the ID block */

  window_id   = idb->self_id;
  ancestor_id = idb->ancestor_id;

  /* Process the icon text */

  ChkError(windows_process_component_text(idb->self_id, OpenWrit, text, sizeof(text), 0, 1));

  /* Attach handlers for the various actions the window can perform */

  ChkError(event_register_toolbox_handler(idb->self_id, EOpenOK,     openurl_ok,              NULL));
  ChkError(event_register_toolbox_handler(idb->self_id, EOpenCancel, openurl_cancel,          NULL));
  ChkError(event_register_toolbox_handler(idb->self_id, EOpenRG1,    openurl_radio_group_one, NULL));

  ChkError(event_register_wimp_handler(idb->self_id,
                                       Wimp_EKeyPressed,
                                       openurl_key_handler,
                                       NULL));

  ChkError(event_register_wimp_handler(idb->self_id,
                                       Wimp_EMouseClick,
                                       openurl_click,
                                       NULL));

  /* Make sure the radios are up to date */

  openurl_radio_group_one(eventcode, event, idb, handle);

  /* Read the existing contents into the static openurl_contents block */

  ChkError(openurl_read_contents(idb->self_id, &contents));

  /* Do we have a History? */

  if (history_empty(NULL)) set_gadget_state(idb->self_id, OpenHistory, 1);
  else                     set_gadget_state(idb->self_id, OpenHistory, 0);

  /* Was the menu that generated this dialogue - if any - opened */
  /* over a link? If so, write the URL to the dialogue.          */
  /*                                                             */
  /* See openurl_to_show_from_menu for more details.             */

  if (open_hst)
  {
    if (ISLINK(open_hst))
    {
      /* Don't put internal URLs in there! */

      if (!urlutils_internal_extra(open_hst->anchor))
      {
        StrNCpy0(contents.url, open_hst->anchor);
        ChkError(openurl_set_contents(idb->self_id, &contents));
      }
    }
    else if (
              open_hst->style & IMG ||
              (
                open_hst->tagno         == TAG_INPUT &&
                HtmlINPUTtype(open_hst) == inputtype_IMAGE
              )
            )
    {
      /* If it is an image, write the image source URL to the dialogue */

      StrNCpy0(contents.url, open_hst->src);
      ChkError(openurl_set_contents(idb->self_id, &contents));
    }
    else if (ISOBJECT(open_hst))
    {
      const char   * data;
      const char   * current;
      browser_data * b = NULL;

      if (ancestor_id) toolbox_get_client_handle(0, idb->self_id, (void *) &b);
      if (b && !is_known_browser(b)) b = NULL;

      /* If it is an Object, write an appropriate URL in there, */
      /* remembering to relativise it where possible.           */

      data            = HtmlOBJECTdata(open_hst);
      if (!data) data = HtmlOBJECTcodebase(open_hst);

      if (b)
      {
        current = browser_fetch_url(b);
        if (!current) current = browser_current_url(b);

        if (current)
        {
          const char * newdata;

          newdata = HtmlRelativiseURL(current, data, open_hst);

          if (newdata) data = newdata;
        }
      }

      StrNCpy0(contents.url, data);
      ChkError(openurl_set_contents(idb->self_id, &contents));
    }

    /* Clear the value */

    open_hst = NULL;
  }

  return 1;
}

/*************************************************/
/* openurl_to_show_from_menu()                   */
/*                                               */
/* Called when the EOpenToBeShownMenu event is   */
/* generated, typically when the Open URL window */
/* is about to be shown from a menu item.        */
/*                                               */
/* To be able to show the URL of a link in the   */
/* window, menu functions have to read the       */
/* token the pointer is over and remember it.    */
/* But to ensure this doesn't get out of date,   */
/* the value is cleared when the menu is hidden. */
/*                                               */
/* Unhelpfully, the Toolbox sends events out in  */
/* an order that means the value is cleared      */
/* before the EOpenToBeShownMisc event is        */
/* raised.                                       */
/*                                               */
/* To get round that, the menu entry itself      */
/* raises EOpenToBeShownMenu, so this function   */
/* is called. It reads the value and stores it   */
/* locally - great... Two copies hanging around. */
/* Anyway, when the EOpenToBeShownMisc event     */
/* finally arrives, openurl_to_be_shown is       */
/* called, reads the value set here, acts on it, */
/* and clears the value to ensure correct        */
/* behaviour on future calls.                    */
/*                                               */
/* All this because the events arrive in a silly */
/* order. Sigh.                                  */
/*                                               */
/* Parameters are as standard for a Toolbox      */
/* event handler.                                */
/*************************************************/

int openurl_to_show_from_menu(int eventcode, ToolboxEvent * event, IdBlock * idb, void * handle)
{
  open_hst = menus_document_opened_over();

  return 1;
}

/*************************************************/
/* openurl_update_popup()                        */
/*                                               */
/* Ensures that the greyed/ungreyed state of the */
/* History menu popup in the Open URL dialogue   */
/* is up to date.                                */
/*************************************************/

void openurl_update_popup(void)
{
  if (!window_id) return;

  if (history_empty(NULL)) set_gadget_state(window_id, OpenHistory, 1);
  else                     set_gadget_state(window_id, OpenHistory, 0);
}

/*************************************************/
/* openurl_ok()                                  */
/*                                               */
/* Handles clicks on the 'OK' button in the      */
/* Open URL dialogue.                            */
/*                                               */
/* Parameters are as standard for a Toolbox      */
/* event handler.                                */
/*************************************************/

static int openurl_ok(int eventcode, ToolboxEvent * event, IdBlock * idb, void * handle)
{
  openurl_contents          localcontents;
  WimpGetPointerInfoBlock   info;
  browser_data            * b;
  browser_data            * ancestor;

  /* Work out where the dialogue came from */

  ChkError(wimp_get_pointer_info(&info));

  if (!idb->ancestor_id) b = ancestor = NULL;
  else
  {
    ChkError(toolbox_get_client_handle(0, idb->ancestor_id, (void *) &b));

    if (is_known_browser(b)) ancestor = b->ancestor;
    else                     ancestor = b = NULL;
  }

  /* Read the dialogue contents */

  ChkError(openurl_read_contents(idb->self_id, &localcontents));

  /* If Select was pressed, the dialogue will close, so */
  /* remember the current contents for future reference */
  /* (no button => Return was pressed)                  */

  if ((info.button_state & Wimp_MouseButtonSelect) || !info.button_state) contents = localcontents;

  /* Fetch the indicated URL */

  if (*localcontents.url)
  {
    /* If asked to open in a new window or saving the object, */
    /* open a new window (this will be a small fetch window   */
    /* in the latter case).                                   */

    if (localcontents.in_new || localcontents.save_link || !b)
    {
      ChkError(windows_create_browser(localcontents.url,
                                      NULL,
                                      NULL,
                                      NULL,
                                      localcontents.save_link ? Windows_CreateBrowser_SaveToFile : Windows_CreateBrowser_Normal));
    }

    /* Otherwise, open the URL in the browser window from which */
    /* the dialogue was obtained in the first place.            */

    else
    {
      browser_data * fetch;

      /* Work out which existing window to fetch to */

      if (localcontents.in_this || localcontents.save_link) fetch = b;
      else                                                  fetch = ancestor;

      /* Set that window's save_link and allow_cancel */
      /* flags according to the dialogue contents     */

      fetch->save_link = localcontents.save_link;
      if (fetch->save_link) b->allow_cancel = 0;

      /* Initiate the fetch */

      ChkError(fetchpage_new(fetch, localcontents.url, 1, 1));
    }
  }

  if ((info.button_state & Wimp_MouseButtonSelect) || !info.button_state)
  {
    ChkError(openurl_close(0, 0));
  }

  return 1;
}

/*************************************************/
/* openurl_cancel()                              */
/*                                               */
/* Handles clicks on the 'Cancel' button in the  */
/* Open URL dialogue.                            */
/*                                               */
/* Parameters are as standard for a Toolbox      */
/* event handler.                                */
/*************************************************/

static int openurl_cancel(int eventcode, ToolboxEvent * event, IdBlock * idb, void * handle)
{
  WimpGetPointerInfoBlock info;

  /* Restore the old contents */

  ChkError(openurl_set_contents(window_id, &contents));

  /* If Select was pressed, the dialogue should close. */
  /* (No button => Escape was pressed).                */

  ChkError(wimp_get_pointer_info(&info));

  if ((info.button_state & Wimp_MouseButtonSelect) || !info.button_state)
  {
    ChkError(openurl_close(0, 0));
  }

  return 1;
}

/*************************************************/
/* openurl_close()                               */
/*                                               */
/* If the Open URL dialogue is opened, this will */
/* close it, deregistering any associated event  */
/* handlers.                                     */
/*                                               */
/* Parameters: An object ID, or 0. If not zero,  */
/*             the ID must match the ancestor    */
/*             recorded when the dialogue was    */
/*             opened or no action is taken.     */
/*                                               */
/*             0 to close the dialogue, 1 to do  */
/*             everything except that.           */
/*************************************************/

_kernel_oserror * openurl_close(ObjectId ancestor, int do_not_close)
{
  _kernel_oserror * e = NULL;

  if (ancestor && ancestor != ancestor_id) return NULL;

  if (window_id)
  {
    /* Deregister associated event handlers */

    e = event_deregister_toolbox_handlers_for_object(window_id);
    if (e) goto openurl_close_exit;

    e = event_deregister_wimp_handlers_for_object(window_id);
    if (e) goto openurl_close_exit;

    /* Restore the old contents */

    e = openurl_set_contents(window_id, &contents);
    if (e) goto openurl_close_exit;

    /* Close the dialogue */

    if (!do_not_close) e = toolbox_hide_object(0, window_id);
  }

openurl_close_exit:

  ancestor_id = window_id = 0;
  return e;
}

/*************************************************/
/* openurl_radio_group_one()                     */
/*                                               */
/* Looks at radio group one and greys or ungreys */
/* items as required. Usually used as a handler  */
/* for when the selection therein changes, but   */
/* can be used in a more general purpose way.    */
/*                                               */
/* Parameters are as standard for a Toolbox      */
/* event handler.                                */
/*************************************************/

static int openurl_radio_group_one(int eventcode, ToolboxEvent * event, IdBlock * idb, void * handle)
{
  _kernel_oserror * e;
  browser_data    * b;
  browser_data    * ancestor;
  int               state;

  /* Note that few errors are reported here - this allows items to be */
  /* removed from the window without causing errors to appear.        */

  if (!idb->ancestor_id) b = ancestor = NULL;
  else
  {
    ChkError(toolbox_get_client_handle(0, idb->ancestor_id, (void *) &b));

    if (is_known_browser(b)) ancestor = b->ancestor;
    else                     ancestor = b = NULL;
  }

  /* If b is NULL, this was not opened from a browser window */

  if (!b)
  {
    /* Grey out the gadget. Try to read its state, and, if this */
    /* succeds and the gadget was selected, then select the     */
    /* 'Open in new window' gadget instead - this will never be */
    /* greyed out.                                              */

    gadget_set_flags(0,
                     idb->self_id,
                     OpenInThis,
                     Gadget_Faded);

    e = radiobutton_get_state(0,
                              idb->self_id,
                              OpenInThis,
                              &state,
                              NULL);

    if (!e && state) radiobutton_set_state(0,
                                           idb->self_id,
                                           OpenInNew,
                                           1);
  }
  else gadget_set_flags(0,
                        idb->self_id,
                        OpenInThis,
                        0);

  /* If ancestor is NULL, this was not opened from a frame */

  if (!ancestor)
  {
    gadget_set_flags(0,
                     idb->self_id,
                     OpenInParent,
                     Gadget_Faded);

    e = radiobutton_get_state(0,
                              idb->self_id,
                              OpenInParent,
                              &state,
                              NULL);

    if (!e && state) radiobutton_set_state(0,
                                           idb->self_id,
                                           OpenInNew,
                                           1);
  }
  else gadget_set_flags(0,
                        idb->self_id,
                        OpenInParent,
                        0);
  return 1;
}

/*************************************************/
/* openurl_click()                               */
/*                                               */
/* Handles Wimp mouse click events in the Open   */
/* URL dialogue.                                 */
/*                                               */
/* Parameters are as standard for a Wimp event   */
/* handler.                                      */
/*************************************************/

static int openurl_click(int eventcode, WimpPollBlock * b, IdBlock * idb, void * handle)
{
  int used = 0;

  switch (idb->self_component)
  {
    case OpenHistory:
    {
      ChkError(history_menu_popup(NULL,
                                  idb->self_id,
                                  idb->self_component,
                                  1,
                                  b->mouse_click.buttons & Wimp_MouseButtonAdjust ? !choices.show_urls : choices.show_urls));
      used = 1;
    }
    break;
  }

  return used;
}

/*************************************************/
/* openurl_key_handler()                         */
/*                                               */
/* Handles a few key pressed events in the Open  */
/* URL dialogue.                                 */
/*                                               */
/* Parameters are as standard for a Wimp event   */
/* handler.                                      */
/*************************************************/

static int openurl_key_handler(int eventcode, WimpPollBlock * b, IdBlock * idb, void * handle)
{
  _kernel_oserror * e;
  int               key;

  key = ((WimpKeyPressedEvent *) b)->key_code;

  switch (key)
  {
    case akbd_TabK + akbd_Ctl:
    {
      char url[Limits_URLBarWrit];
      int  changed = 0;

      /* Read whatever is in the URL bar writable */

      *url = 0;

      e = writablefield_get_value(0,
                                  idb->self_id,
                                  OpenWrit,
                                  url,
                                  sizeof(url),
                                  NULL);

      if (!e)
      {
        url[sizeof(url) - 1] = 0; /* (Ensure termination) */

        /* Try and find something appropriate in the hotlist, */
        /* then the history.                                  */

        #ifndef REMOTE_HOTLIST
          changed = hotlist_find_match(url, sizeof(url));
        #endif

        if (!changed) changed = history_find_match(url, sizeof(url));

        if (changed)
        {
          /* Update the URL writable */

          writablefield_set_value(0,
                                  idb->self_id,
                                  OpenWrit,
                                  url);
        }
      }

      key = 0;
    }
    break;

    case akbd_TabK + akbd_Sh:
    {
      char url[Limits_URLBarWrit];
      int  changed;

      /* Read whatever is in the URL bar writable */

      *url = 0;

      e = writablefield_get_value(0,
                                  idb->self_id,
                                  OpenWrit,
                                  url,
                                  sizeof(url),
                                  NULL);

      if (!e)
      {
        url[sizeof(url) - 1] = 0; /* (Ensure termination) */

        /* Cycle the protocol specifier (adding one in if not already present) */

        changed = urlutils_cycle_protocol(url, sizeof(url));

        if (changed)
        {
          /* Update the URL writable */

          writablefield_set_value(0,
                                  idb->self_id,
                                  OpenWrit,
                                  url);
        }
      }

      key = 0;
    }
    break;
  }

  if (key) wimp_process_key(key);

  return 1;
}