---

Terminal.c

Go to the documentation of this file.

/*
 *    gui - [gega user interface] the flexible solution for user interface problems
 *    Copyright (C) 2002  Gergely Gati
 *
 *    This program 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; version 2 of the License.
 *
 *    This program 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 this program; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *    Gergely Gati
 *      email:           g.gati@freemail.hu
 *      AIM screenname:  GatiGergely
 *      ICQ number:      93131690
 *
 */
/* Terminal.c */

#include "debug.h"
#include "types.h"
#include "Bases.h"
#include "Memory.h"
#include "Terminal.h"
#include "Glw.h"
#include "Endian.h"
#include "Marshal.h"


//Declare call_vector[]
static u32 (*call_vector[TERM_FUNC_DONE-TERM_FUNCBASE+1])(tag *);


inline static u32 term_RpcCallA(u32 conn, u16 code, tag *taglist)
{
  u32 ret=~0L;
  int mlen;
  u8 *msg,*m;

  debug_Begin();

  if(GLW_ENDIAN==glw_GetTerminalByteOrder(conn))
  {
    mlen=marshal_GetTaglistMsgLen(taglist)+4;
    if(NULL!=(msg=mem_malloc(mlen)))
    {
      m=msg+2;
      (*(u16 *)m)=endian_ToAlien16(code);
      m+=2;
      marshal_PutTaglistC(m,taglist);
      ret=glw_SendTerm(conn,msg+2,mlen-2);
      mem_free(msg);
    }
  }
  else
  {
    mlen=marshal_GetTaglistMsgLen(taglist)+4;
    if(NULL!=(msg=mem_malloc(mlen)))
    {
      m=msg+2;
      *((u16 *)m)=code;
      m+=2;
      marshal_PutTaglist(m,taglist);
      ret=glw_SendTerm(conn,msg+2,mlen-2);
      mem_free(msg);
    }
  }

  debug_End();

  return(ret);
}


inline static u32 term_RpcCallR(u32 conn, u16 code, tag *taglist)
{
  u32 ret=~0L;
  int mlen;
  u8 *msg,*m;
  u8 buff[4];

  debug_Begin();

  if(GLW_ENDIAN==glw_GetTerminalByteOrder(conn))
  {
    mlen=marshal_GetTaglistMsgLen(taglist)+4;
    if(NULL!=(msg=mem_malloc(mlen)))
    {
      m=msg+2;
      *((u16 *)m)=code;
      m+=2;
      marshal_PutTaglist(m,taglist);
      glw_SendTerm(conn,msg+2,mlen-2);
      mem_free(msg);
      glw_ReadTerm(conn,buff,4);
      ret=*((u32 *)buff);
    }
  }
  else
  {
    mlen=marshal_GetTaglistMsgLen(taglist)+4;
    if(NULL!=(msg=mem_malloc(mlen)))
    {
      m=msg+2;
      *((u16 *)m)=endian_ToAlien16(code);
      m+=2;
      marshal_PutTaglistC(m,taglist);
      glw_SendTerm(conn,msg+2,mlen-2);
      mem_free(msg);
      glw_ReadTerm(conn,buff,4);
      ret=endian_FromAlien32(*((u32 *)buff));
    }
  }

  debug_End();

  return(ret);
}


inline static u32 term_RpcCallT(u32 conn, u16 code, tag *taglist)
{
  u32 ret=~0L;
  int mlen;
  u8 *msg,*m;
  tag *newtaglist=NULL,*tags,*mod;

  debug_Begin();

  if(GLW_ENDIAN==glw_GetTerminalByteOrder(conn))
  {
    mlen=marshal_GetTaglistMsgLen(taglist)+4;
    if(NULL!=(msg=mem_malloc(mlen)))
    {
      m=msg+2;
      *((u16 *)m)=code;
      m+=2;
      marshal_PutTaglist(m,taglist);
      glw_SendTerm(conn,msg+2,mlen-2);
      glw_ReadTerm(conn,msg,mlen-4);
      newtaglist=marshal_GetTaglist(&msg);
      mem_free(msg);
    }
  }
  else
  {
    mlen=marshal_GetTaglistMsgLen(taglist)+4;
    if(NULL!=(msg=mem_malloc(mlen)))
    {
      m=msg+2;
      *((u16 *)m)=endian_ToAlien16(code);
      m+=2;
      marshal_PutTaglistC(m,taglist);
      glw_SendTerm(conn,msg+2,mlen-2);
      glw_ReadTerm(conn,msg,mlen-4);
      newtaglist=marshal_GetTaglistC(&msg);
      mem_free(msg);
    }
  }
  if(newtaglist!=NULL)
  {
    ret=0L;
    for(tags=newtaglist;tags->Name!=TAG_DONE;tags=tag_GetNextTag(tags))
    {
      if(NULL!=(mod=tag_FindTag(taglist,tags->Name)))
      {
        if((tags->Name&TAGT_RECT)!=0)
        {
          memcpy(((Rect_t *)mod->Data),((Rect_t *)tags->Data),sizeof(Rect_t));
        }
        else if((tags->Name&TAGT_STRING)!=0||(tags->Name&TAGT_VECTOR)!=0||(tags->Name&TAGT_PIXELS)!=0)
        {
          mod->Data=0L;
          debug_Warning("Strings and binaries are don't copied back");
        }
        else mod->Data=tags->Data;
      }
    }
  }
  marshal_FreeTaglist(newtaglist);

  debug_End();

  return(ret);
}


inline static u32 term_RpcCall(u32 conn, u16 code, tag *taglist)
{
  u32 ret=~0L;

  debug_Begin();

  if(code!=RPC_INVALID&&conn!=0L&&taglist!=NULL)
  {
    if((code&RPCF_RETVAL)!=0) ret=term_RpcCallR(conn,code,taglist);
    else if((code&RPCF_TAGLIST)!=0) ret=term_RpcCallT(conn,code,taglist);
    else ret=term_RpcCallA(conn,code,taglist);
  }
  else debug_Error("Invalid parameter");

  debug_End();

  return(ret);
}




u32 term_StartMouseTracking(u32 firsttag, ...)
{
  return(term_StartMouseTrackingTL((tag *)&firsttag));
}
u32 term_StartMouseTrackingTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_STARTMOUSETRACKING,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_StopMouseTracking(u32 firsttag, ...)
{
  return(term_StopMouseTrackingTL((tag *)&firsttag));
}
u32 term_StopMouseTrackingTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_STOPMOUSETRACKING,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_DragWindow(u32 firsttag, ...)
{
  return(term_DragWindowTL((tag *)&firsttag));
}
u32 term_DragWindowTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_DRAGWINDOW,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_ResizeWindow(u32 firsttag, ...)
{
  return(term_ResizeWindowTL((tag *)&firsttag));
}
u32 term_ResizeWindowTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_RESIZEWINDOW,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_SetColor(u32 firsttag, ...)
{
  return(term_SetColorTL((tag *)&firsttag));
}
u32 term_SetColorTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_SETCOLOR,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_SetBackground(u32 firsttag, ...)
{
  return(term_SetBackgroundTL((tag *)&firsttag));
}
u32 term_SetBackgroundTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_SETBACKGROUND,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_DrawLine(u32 firsttag, ...)
{
  return(term_DrawLineTL((tag *)&firsttag));
}
u32 term_DrawLineTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_DRAWLINE,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_DrawRect(u32 firsttag, ...)
{
  return(term_DrawRectTL((tag *)&firsttag));
}
u32 term_DrawRectTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_DRAWRECT,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_DrawFilledRect(u32 firsttag, ...)
{
  return(term_DrawFilledRectTL((tag *)&firsttag));
}
u32 term_DrawFilledRectTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_DRAWFILLEDRECT,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_DrawPixel(u32 firsttag, ...)
{
  return(term_DrawPixelTL((tag *)&firsttag));
}
u32 term_DrawPixelTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_DRAWPIXEL,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_OpenFont(u32 firsttag, ...)
{
  return(term_OpenFontTL((tag *)&firsttag));
}
u32 term_OpenFontTL(tag *taglist)
{
  u32 conn;
  u32 ret=~0L;

  debug_Begin();

  conn=(u32)tag_GetTagData(taglist,TAG_GLW_CONN,0L);
  ret=term_RpcCall(conn,RPC_OPENFONT,taglist);

  debug_End();

  return(ret);
}


u32 term_CloseFont(u32 firsttag, ...)
{
  return(term_CloseFontTL((tag *)&firsttag));
}
u32 term_CloseFontTL(tag *taglist)
{
  u32 font;
  u32 ret=~0L;

  debug_Begin();

  font=(u32)tag_GetTagData(taglist,TAG_GLW_FONT,0L);
  if(font!=0L)
  {
    ret=term_RpcCall(glw_GetFontConnection(font),RPC_CLOSEFONT,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_DrawText(u32 firsttag, ...)
{
  return(term_DrawTextTL((tag *)&firsttag));
}
u32 term_DrawTextTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_DRAWTEXT,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_GetFontSize(u32 firsttag, ...)
{
  return(term_GetFontSizeTL((tag *)&firsttag));
}
u32 term_GetFontSizeTL(tag *taglist)
{
  u32 font;
  u32 ret=~0L;

  debug_Begin();

  font=(u32)tag_GetTagData(taglist,TAG_GLW_FONT,0L);
  if(font!=0L)
  {
    ret=term_RpcCall(glw_GetFontConnection(font),RPC_GETFONTSIZE,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_GetTextLength(u32 firsttag, ...)
{
  return(term_GetTextLengthTL((tag *)&firsttag));
}
u32 term_GetTextLengthTL(tag *taglist)
{
  u32 font;
  u32 ret=~0L;

  debug_Begin();

  font=(u32)tag_GetTagData(taglist,TAG_GLW_FONT,0L);
  if(font!=0L)
  {
    ret=term_RpcCall(glw_GetFontConnection(font),RPC_GETTEXTLENGTH,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_PutImage(u32 firsttag, ...)
{
  return(term_PutImageTL((tag *)&firsttag));
}
u32 term_PutImageTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_PUTIMAGE,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_GetScreenDimensions(u32 firsttag, ...)
{
  return(term_GetScreenDimensionsTL((tag *)&firsttag));
}
u32 term_GetScreenDimensionsTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_GETSCREENDIMENSIONS,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_SetWindowDimensions(u32 firsttag, ...)
{
  return(term_SetWindowDimensionsTL((tag *)&firsttag));
}
u32 term_SetWindowDimensionsTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_SETWINDOWDIMENSIONS,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_GetWindowDimensions(u32 firsttag, ...)
{
  return(term_GetWindowDimensionsTL((tag *)&firsttag));
}
u32 term_GetWindowDimensionsTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_GETWINDOWDIMENSIONS,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_SetPointer(u32 firsttag, ...)
{
  return(term_SetPointerTL((tag *)&firsttag));
}
u32 term_SetPointerTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_SETPOINTER,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_SetWindowTransparency(u32 firsttag, ...)
{
  return(term_SetWindowTransparencyTL((tag *)&firsttag));
}
u32 term_SetWindowTransparencyTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_SETWINDOWTRANSPARENCY,taglist);
  }

  debug_End();

  return(ret);
}




u32 term_OpenWindow(u32 firsttag, ...)
{
  return(term_OpenWindowTL((tag *)&firsttag));
}
u32 term_OpenWindowTL(tag *taglist)
{
  u32 conn;
  u32 ret=~0L;

  debug_Begin();

  conn=(u32)tag_GetTagData(taglist,TAG_GLW_CONN,0L);
  ret=term_RpcCall(conn,RPC_OPENWINDOW,taglist);

  debug_End();

  return(ret);
}


u32 term_CloseWindow(u32 firsttag, ...)
{
  return(term_CloseWindowTL((tag *)&firsttag));
}
u32 term_CloseWindowTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_CLOSEWINDOW,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_RefreshWindow(u32 firsttag, ...)
{
  return(term_RefreshWindowTL((tag *)&firsttag));
}
u32 term_RefreshWindowTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_REFRESHWINDOW,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_RefreshWindowPartial(u32 firsttag, ...)
{
  return(term_RefreshWindowPartialTL((tag *)&firsttag));
}
u32 term_RefreshWindowPartialTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_REFRESHWINDOWPARTIAL,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_ClearWindow(u32 firsttag, ...)
{
  return(term_ClearWindowTL((tag *)&firsttag));
}
u32 term_ClearWindowTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_CLEARWINDOW,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_GetWindowUserdata(u32 firsttag, ...)
{
  return(term_GetWindowUserdataTL((tag *)&firsttag));
}
u32 term_GetWindowUserdataTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_GETWINDOWUSERDATA,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_SetWindowLimits(u32 firsttag, ...)
{
  return(term_SetWindowLimitsTL((tag *)&firsttag));
}
u32 term_SetWindowLimitsTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_SETWINDOWLIMITS,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_SetWindowState(u32 firsttag, ...)
{
  return(term_SetWindowStateTL((tag *)&firsttag));
}
u32 term_SetWindowStateTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_SETWINDOWSTATE,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_SetWindowShape(u32 firsttag, ...)
{
  return(term_SetWindowShapeTL((tag *)&firsttag));
}
u32 term_SetWindowShapeTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_SETWINDOWSHAPE,taglist);
  }

  debug_End();

  return(ret);
}


u32 term_GetWindowState(u32 firsttag, ...)
{
  return(term_GetWindowStateTL((tag *)&firsttag));
}
u32 term_GetWindowStateTL(tag *taglist)
{
  u32 window;
  u32 ret=~0L;

  debug_Begin();

  window=(u32)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  if(window!=0L)
  {
    ret=term_RpcCall(glw_GetConnection(window),RPC_GETWINDOWSTATE,taglist);
  }

  debug_End();

  return(ret);
}




u32 term_Call(int function, u32 firsttag, ...)
{
  return(term_CallTL(function,(tag *)&firsttag));
}
u32 term_CallTL(int function, tag *taglist)
{
  u32 ret=~0L;

  debug_Begin();

  if(function>=TERM_FUNCBASE&&function<TERM_FUNC_DONE)
  {
    ret=call_vector[function-TERM_FUNCBASE](taglist);
  }
  else debug_Warning("%s(): Function code out of range! code=0x%04x",__FUNCTION__,function);

  debug_End();

  return(ret);
}


int term_Init(void)
{

  debug_Begin();

//Initialize call vector BEGIN - put this into the init function of this module
  call_vector[TERM_STARTMOUSETRACKING-TERM_FUNCBASE]=term_StartMouseTrackingTL;
  call_vector[TERM_STOPMOUSETRACKING-TERM_FUNCBASE]=term_StopMouseTrackingTL;
  call_vector[TERM_DRAGWINDOW-TERM_FUNCBASE]=term_DragWindowTL;
  call_vector[TERM_RESIZEWINDOW-TERM_FUNCBASE]=term_ResizeWindowTL;
  call_vector[TERM_SETCOLOR-TERM_FUNCBASE]=term_SetColorTL;
  call_vector[TERM_SETBACKGROUND-TERM_FUNCBASE]=term_SetBackgroundTL;
  call_vector[TERM_DRAWLINE-TERM_FUNCBASE]=term_DrawLineTL;
  call_vector[TERM_DRAWRECT-TERM_FUNCBASE]=term_DrawRectTL;
  call_vector[TERM_DRAWFILLEDRECT-TERM_FUNCBASE]=term_DrawFilledRectTL;
  call_vector[TERM_DRAWPIXEL-TERM_FUNCBASE]=term_DrawPixelTL;
  call_vector[TERM_OPENFONT-TERM_FUNCBASE]=term_OpenFontTL;
  call_vector[TERM_CLOSEFONT-TERM_FUNCBASE]=term_CloseFontTL;
  call_vector[TERM_DRAWTEXT-TERM_FUNCBASE]=term_DrawTextTL;
  call_vector[TERM_GETFONTSIZE-TERM_FUNCBASE]=term_GetFontSizeTL;
  call_vector[TERM_GETTEXTLENGTH-TERM_FUNCBASE]=term_GetTextLengthTL;
  call_vector[TERM_PUTIMAGE-TERM_FUNCBASE]=term_PutImageTL;
  call_vector[TERM_GETSCREENDIMENSIONS-TERM_FUNCBASE]=term_GetScreenDimensionsTL;
  call_vector[TERM_SETWINDOWDIMENSIONS-TERM_FUNCBASE]=term_SetWindowDimensionsTL;
  call_vector[TERM_GETWINDOWDIMENSIONS-TERM_FUNCBASE]=term_GetWindowDimensionsTL;
  call_vector[TERM_SETPOINTER-TERM_FUNCBASE]=term_SetPointerTL;
  call_vector[TERM_SETWINDOWTRANSPARENCY-TERM_FUNCBASE]=term_SetWindowTransparencyTL;
  bases_modules.term_Call=term_Call;
  bases_modules.term_CallTL=term_CallTL;
//Initialize call vector END

  debug_End();

  return(0);
}


void term_CleanUp(void)
{
  debug_Begin();
  debug_End();
}

---