/*-----------------------------------------------------------------------------
    javascript.js
-----------------------------------------------------------------------------*/

function javascript()
  {
  //alert( 'construct js...');

  /*-------------------------------------------------------------------------*/
  function initialize()
    {
    var frame=swixlib.currentFrame;
    //swixlib.showSWiXlib( "init javascript, my name="+self.name+":");
    //alert( 'init js, my name='+self.name+';');
    this.stack=new Array();
    if (!this.procedures) 
      { 
      if (!swixlib.S.javascript.procedures)
        { swixlib.S.javascript.procedures=new Array();  }
      this.procedures=swixlib.S.javascript.procedures; 
      }
    this.validator=new Array();
    this.initializeFrame( frame);
    }
  this.initialize=initialize;
 
  /*-------------------------------------------------------------------------*/
  function initializeFrame( frame)
    {
    frame.checkFrame=this.checkFrame;
    frame.stackProcedure=this.stackProcedure_;
    frame.registerProcedure=this.registerProcedure_;
    frame.castProcedure=this.castProcedure_;
    frame.castForm=this.castForm_;
    frame.registerFormValidator=this.registerFormValidator_;
    for (m in frame.swixlib.S)
      {
      //alert( 'module='+m+', frame='+frame.name);
      if ((m!='javascript') && frame.swixlib[m].initializeFrame)
        { 
        //alert( 'initFrame '+m+', frame='+frame.name);
        //frame.swixlib[m].initializeFrame( frame); 
        }
      }
    }
  this.initializeFrame=initializeFrame;

  /*-------------------------------------------------------------------------*/
  function checkFrame( frame, url)
    {
    if (   !frame || !frame.swixlib || !frame.swixlib.rootFrame
         ||frame.swixlib.rootFrame==frame)
      {
      alert('re-initializing...');
      frame.location.replace( url);
      }
    else
      {
      // alert('frame ok');
      }
    }
  this.checkFrame=checkFrame;
  
  /*-------------------------------------------------------------------------*/
  function stackProcedure_( key, proc, obj, args)
    { swixlib.javascript.stackProcedure( key, proc, obj, args); }
  this.stackProcedure_=stackProcedure_;

  /*-------------------------------------------------------------------------*/
  function stackProcedure( key, proc, obj, args)
    {
    // alert("this.stack.length="+i);
    var i=this.stack.length;
    this.stack[i]=new Object;
    this.stack[i].key=key;
    this.stack[i].proc=proc;
    this.stack[i].obj=obj;
    this.stack[i].args=args;
    this.stack[i].done=false;
    }
  this.stackProcedure=stackProcedure;
  
  /*-------------------------------------------------------------------------*/
  function registerProcedure_( key, proc, obj, args, validator, submit)
    { 
    swixlib.javascript.registerProcedure( 
                                key, proc, obj, args, validator, submit);
    }
  this.registerProcedure_=registerProcedure_;

  /*-------------------------------------------------------------------------*/
  function registerProcedure( key, proc, obj, args, validator, submit)
    {
    //alert("registering...key="+key);
    if (submit==null) { submit=false; }
    this.procedures[key]=new Object;
    this.procedures[key].proc=proc;
    this.procedures[key].obj=obj;
    this.procedures[key].args=args;
    this.procedures[key].cast=false;
    this.procedures[key].done=false;
    this.procedures[key].validator=validator;
    this.procedures[key].submit=submit;
    }
  this.registerProcedure=registerProcedure;
  
  /*-------------------------------------------------------------------------*/
  function castProcedure_( key)
    { swixlib.javascript.castProcedure( this, key); }
  this.castProcedure_=castProcedure_;

  /*-------------------------------------------------------------------------*/
  function castProcedure( frame, key)
    {
    //alert("casting...key="+key);
    this.frame=frame;
    if (key && this.procedures[key].submit)
      { this.castForm( frame, key); }
    else
      {
      if (this.validateKey( key))
        { this.procedures[key].cast=true; }
      }
    }
  this.castProcedure=castProcedure;
  
  /*-------------------------------------------------------------------------*/
  function clearProcedureList( form)
    { form.javascript_procedureList.value=''; }
  this.clearProcedureList=clearProcedureList;
  
  /*-------------------------------------------------------------------------*/
  function addProcedure( form, proc, obj, args)
    {
    if (proc.length>0) 
      { form.javascript_procedureList.value+=proc+'|'+obj+'|'+args+"\n"; }
    }
  this.addProcedure=addProcedure;
  
  /*-------------------------------------------------------------------------*/
  function registerFormValidator( cmd)
    { 
    var i=this.validator.length;
    this.validator[i]=new Object;
    this.validator[i].cmd=cmd;
    }
  this.registerFormValidator=registerFormValidator;

  /*-------------------------------------------------------------------------*/
  function registerFormValidator_( cmd)
    { swixlib.javascript.registerFormValidator( cmd); }
  this.registerFormValidator_=registerFormValidator_;

  /*-------------------------------------------------------------------------*/
  function validateForm( key)
    {
    var i;
    for (i=0; i<this.validator.length; i++)
      {
      if (!eval( this.validator[i].cmd)) { return false; }
      }
    return true;
    }
  this.validateForm=validateForm;

  /*-------------------------------------------------------------------------*/
  function validateKey( key)
    { 
    //alert("validateKey...key="+key); 
    if (key && this.procedures[key] 
        && this.procedures[key].validator)
      { return eval( this.procedures[key].validator); }
    return true;
    }
  this.validateKey=validateKey;

  /*-------------------------------------------------------------------------*/
  function castForm_( key)
    { swixlib.javascript.castForm( this, key); }
  this.castForm_=castForm_;

  /*-------------------------------------------------------------------------*/
  function castForm( frame, key)
    { 
    //alert("castForm...frame, key="+frame.name+', '+key); 
    this.frame=frame;
    if (!this.validateKey( key)) { return; }
    if (this.validateForm())
      {
      js="swixlib.javascript.goLevel( 'link', -1, '"+ key+"');";
      frame.setTimeout( js, 1);
      }
    }
  this.castForm=castForm;
  
  /*-------------------------------------------------------------------------*/
  function submitForm( frame)
    { 
    frame.focus(); // damit die onChange-Event-Handler noch gefeuert werden
    // das laeuft nicht anders im IE 4, weil die verschiedenen
    // gleichzeitig arbeitende Event-Handler (onSubmit/onChange) waehrend
    // ihren Tasks wie eigene Kopien der Daten benutzen, die untereinander
    // erst dann brauchbar werden, nachdem die Handler zurueckkehren...
    // Das eigentliche Submit wird deshalb aufgeschoben und erst
    // ausgefuehrt, nachdem die Handler zurueck sind.
    //alert( 'submitForm( '+frame.name+');');
    this.castForm( frame);
    return false; // Form nicht submitten...
    }
  this.submitForm=submitForm;
  
  /*-------------------------------------------------------------------------*/
  function goLevel( typ, level, key)
    { // typ='form' | 'link' 
    var e, i, k;
    var f=this.frame.document.javascript_form; 
    var applicationName=f.javascript_frameName.value; 
    //alert( "goLevel frame.name="+this.frame.name);
    if (f.webframe_currentFrame)
      { f.webframe_currentFrame.value=this.frame.name; }
    this.clearProcedureList(f);
    // zuerst den Stack abarbeiten...
    if (level<0) { level=this.stack.length; }
    for (i=0; (i<this.stack.length) && (i<=level); i++)
      {
      if (this.stack[i].key)
        {
        if (!this.stack[i].done)
          {
          var last, j;
          last=i; this.stack[i].done=true;
          for (j=i; (j<this.stack.length) && (j<=level); j++)
            {
            if (this.stack[i].key==this.stack[j].key)
              { last=j; this.stack[j].done=true; }
            }
          this.addProcedure( f, this.stack[last].proc, 
                     this.stack[last].obj, this.stack[last].args);
          }
        }
      else
        {
        this.addProcedure( f, this.stack[i].proc, 
                      this.stack[i].obj, this.stack[i].args);
        }
      }
    // dann die Casts...
    for (k in this.procedures)
      {
      //alert("procedure["+k+"].cast="+this.procedures[k].cast+";\n");
      if (this.procedures[k].cast)
        {
        this.addProcedure( f, this.procedures[k].proc, 
              this.procedures[k].obj, this.procedures[k].args);
        this.procedures[k].cast=false;
        }
      } 
    // und zuletzt die mit key uebergebene Procedure...
    if (key && this.procedures[key])
      {
      this.addProcedure( f, this.procedures[key].proc, 
              this.procedures[key].obj, this.procedures[key].args);
      this.procedures[key].cast=false;
      }
    //alert("submitting...value=\n"+f.javascript_procedureList.value); 
    f.target='javascript_applicationFrame_'+applicationName;
    if (typ=='link') 
      { 
      //f.action='';
      f.submit(); 
      return false;
      }
    return true;  // falls typ=='form' soll es mit submit weiterfahren...
    } 
  this.goLevel=goLevel;
  }
  
loadModule( 'javascript');