---

GlwTerminal.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
 *
 */
/* glw.c */
#include <windows.h>
//#include <shlobj.h>

#ifndef WS_EX_LAYERED
#define WS_EX_LAYERED           0x00080000
#define LWA_ALPHA               0x00000002
#endif // ndef WS_EX_LAYERED

#ifndef MSG_WAITALL
#define MSG_WAITALL 0x100
#endif

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

#include "Bases.h"
#include "NetCommon.h"
#include "Memory.h"
#include "debug.h"
#include "Net.h"
#include "Gui.h"
#include "Common.h"
#include "Endian.h"


typedef DWORD (WINAPI *PSLWA)(HWND, DWORD, BYTE, DWORD);


struct glw_Window
{
  HWND window;
  u32 fgrgb;
  u32 bgrgb;
  COLORREF fgcol; // __BBGGRR
  COLORREF bgcol;
  HBRUSH fgbrush;
  HBRUSH bgbrush;
  HPEN pen;
  LOGBRUSH logbrush;
  HDC hdcMem;
  HBITMAP hbmMem;
  HBITMAP hbmOld;
  RECT wrect;
  u32 flags;
  u32 userdata;
  int minwidth;
  int maxwidth;
  int minheight;
  int maxheight;
  int done;
  struct glw_Connection *conn;
  int state;
  int paint;
  int user_state;
};


struct glw_Connection
{
  struct glw_ConnUser cuser;
  SOCKET sd;
//  DWORD thread_id;
  int window_count;
  struct glw_Window *win;
  struct glw_SockMsg sockmsg;
  u32 completed;
  u8 *write_buffer;
  struct glw_Event curr_event;
  int level;
  int mx,my;
  List_t *windowlist;
  int byteorder;        // 0-little, 1-big (app byte order)
  SOCKET sterm;
  int termbyteorder;
};


struct glw_FontFace
{
  char *face;
  char *win_name;
};

struct glw_Font
{
  Node_t *node;
  struct glw_Connection *conn;
  struct glw_FontFace *face;
  int size;
  u32 style;
  HFONT handle;
  int counter;
};


struct glw_Dir
{
  HANDLE hdir;
  char *filename;
};


#define NWHT_NOWHERE          0x0000
#define NWHT_LEFT           0x0001
#define NWHT_RIGHT            0x0002
#define NWHT_TOP                0x0003
#define NWHT_TOPLEFT        0x0004
#define NWHT_TOPRIGHT         0x0005
#define NWHT_BOTTOM         0x0006
#define NWHT_BOTTOMLEFT   0x0007
#define NWHT_BOTTOMRIGHT    0x0008

#ifndef ANTIALIASED_QUALITY
#define ANTIALIASED_QUALITY 4
#endif

#define GLW_FONTNAME_SIZE   64


struct glw_InternalBMI
{
  BITMAPINFOHEADER bmiHeader;
  RGBQUAD bmiColors[3];
};

//Declare call_vector[]
static u32 (*call_vector[GLW_FUNC_DONE-GLW_FUNCBASE+1])(tag *);

// double buffer variables
static int quit=0;
static int buffsizeX,buffsizeY;
static List_t *windowlist;        //SEMAPHORE PROTECTED!
static WNDCLASSEX WindowClass;
static int sCommandShow;
static List_t *fontfacelist;      //readonly list no need semaphore
static List_t *fontlist;          //SEMAPHORE PROTECTED!
static int wv;          // windows version: 0=>3.1  1=>95  2=>98  3=>NT4  4=>2k  5=>xp
static HINSTANCE sInstance;
static HMODULE user32_DLL;

// app-dependent stuff
static HDC workDC=NULL; // used by glw_GetTextLength() only a) SEMAPHORE PROTECTION, b) window or app specific!


u32 glw_GetConnection(u32 window)
{
  struct glw_Window *win=(struct glw_Window *)window;
  return((u32)win->conn);
}

static void glw_UnloadFontFaces(List_t *faces)
{
  Node_t *node;
  struct glw_FontFace *face;

  debug_Begin();

  while(NULL!=(node=list_GetNodeHead(faces)))
  {
    list_RemoveNode(faces,node);
    if(NULL!=(face=(struct glw_FontFace *)list_GetNodeData(node)))
    {
      if(NULL!=face->face) mem_free(face->face);
      if(NULL!=face->win_name) mem_free(face->win_name);
      mem_free(face);
    }
    list_SetNodeData(node,NULL);
    list_DeleteNode(node);
  }
  list_DeleteList(faces);

  debug_End();

}


static int glw_LoadFontFaces(List_t *faces)
{
  int ret=-1;
  FILE *f;
  char str[GLW_FONTNAME_SIZE];
  struct glw_FontFace *face;
  Node_t *node;
  char *eq;

  debug_Begin();

  if(faces!=NULL)
  {
    if(NULL!=(f=fopen("files/Fonts.list","r")))
    {
      while(NULL!=(fgets(str,GLW_FONTNAME_SIZE,f)))
      {
        str[strlen(str)-1]='\0';
        if(NULL!=(eq=strchr(str,'=')))
        {
          *eq++='\0';
          ret=-1;
          if(NULL!=(node=list_CreateNode()))
          {
            if(NULL!=(face=mem_malloc(sizeof(struct glw_FontFace))))
            {
              if(NULL!=(face->face=mem_malloc(strlen(str)+1)))
              {
                strcpy(face->face,str);
                if(NULL!=(face->win_name=mem_malloc(strlen(eq)+1)))
                {
                  strcpy(face->win_name,eq);
                  list_SetNodeData(node,face);
                  list_InsertNodeTail(faces,node);
                  ret=0;
                }
              }
            }
          }
        }
      }
      fclose(f);
    }
  }

  debug_End();

  return(ret);
}


static struct glw_FontFace *glw_GetFaceWinName(List_t *fflist, char *name)
{
  Node_t *node;
  struct glw_FontFace *face=NULL;

  debug_Begin();

  for(node=list_GetNodeHead(fflist);node!=NULL;node=list_GetNodeNext(fflist,node))
  {
    if(NULL!=(face=list_GetNodeData(node)))
    {
      if(strcmp(face->face,name)==0) break;
    }
  }

  debug_End();

  return(face);
}


static int glw_WindowTransparent(struct glw_Window *win, int percent)
{
  static PSLWA pSetLayeredWindowAttributes=NULL;
  int ret=-1;

  debug_Begin();

  if(NULL==pSetLayeredWindowAttributes) pSetLayeredWindowAttributes=(PSLWA)GetProcAddress(user32_DLL,"SetLayeredWindowAttributes");
  if(pSetLayeredWindowAttributes!=NULL)
  {
    SetWindowLong(win->window,GWL_EXSTYLE,GetWindowLong(win->window,GWL_EXSTYLE)|WS_EX_LAYERED);
    pSetLayeredWindowAttributes(win->window,0,(255*percent)/100,LWA_ALPHA);
    ret=0;
  }

  debug_End();

  return(ret);
}


static void glw_CreateBuffer(struct glw_Window *win, HDC referenceDC, int sizeX, int sizeY)
{
  debug_Begin();

  if((win->flags&GLWF_SMART_REFRESH)!=0)
  {
    win->hdcMem=CreateCompatibleDC(referenceDC);
    win->hbmMem=CreateCompatibleBitmap(referenceDC,sizeX,sizeY);
    win->hbmOld=SelectObject(win->hdcMem, win->hbmMem);
  }
  else win->hdcMem=GetDC(win->window);
  win->fgcol=0x00000000; // __BBGGRR
  win->bgcol=0x00ffffff;
  win->fgbrush=CreateSolidBrush(win->fgcol);
  win->bgbrush=CreateSolidBrush(win->bgcol);
  win->logbrush.lbStyle=BS_SOLID;
  win->logbrush.lbColor=win->fgcol;
  win->pen=ExtCreatePen(PS_COSMETIC|PS_SOLID,1,&win->logbrush,0,NULL);

  debug_End();

}


u32 glw_ClearWindow(u32 firsttag, ...)
{
  return(glw_ClearWindowTL((tag *)&firsttag));
}
u32 glw_ClearWindowTL(tag *taglist)
{
  struct glw_Window *win;

  RECT rc;

  debug_Begin();

  win=(struct glw_Window *)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);

  if(win!=NULL&&win->bgrgb!=GLW_TRANSPARENT)
  {
    rc.left=rc.top=0;
    rc.bottom=buffsizeY;
    rc.right=buffsizeX;
    FillRect(win->hdcMem,&rc,win->bgbrush);
  }

  debug_End();

  return(0L);
}


static void glw_DeleteBuffer(struct glw_Window *win)
{
  debug_Begin();

  DeleteObject(win->fgbrush);
  DeleteObject(win->bgbrush);
  DeleteObject(win->pen);
  if((win->flags&GLWF_SMART_REFRESH)!=0)
  {
    SelectObject(win->hdcMem, win->hbmOld);
    DeleteObject(win->hbmMem);
    DeleteDC(win->hdcMem);
  }

  debug_End();

}


static Node_t *glw_GetNode(HWND win)
{
  Node_t *node;
  Node_t *ret=NULL;
  struct glw_Window *w;

  debug_Begin();

  for(node=list_GetNodeHead(windowlist);node!=NULL;node=list_GetNodeNext(windowlist,node))
  {
    w=(struct glw_Window *)list_GetNodeData(node);
    if(w->window==win) { ret=node; break; }
  }

  debug_End();

  return(ret);
}


static Node_t *glw_GetNode2(struct glw_Connection *conn, HWND win)
{
  Node_t *node;
  Node_t *ret=NULL;
  struct glw_Window *w;

  debug_Begin();

  for(node=list_GetNodeHead(conn->windowlist);node!=NULL;node=list_GetNodeNext(conn->windowlist,node))
  {
    w=(struct glw_Window *)list_GetNodeData(node);
    if(w->window==win) { ret=node; break; }
  }

  debug_End();

  return(ret);
}


static struct glw_Window *glw_GetGlwWindow(HWND w)
{
  struct glw_Window *win=NULL;
  Node_t *node;

  debug_Begin();

  if((node=glw_GetNode(w))!=NULL)
  {
    win=(struct glw_Window *)list_GetNodeData(node);
  }

  debug_End();

  return(win);
}


static int glw_FillEvent(struct glw_Event *ev, struct glw_Window *win)
{
  int ret=-1;
  SYSTEMTIME stime;

  debug_Begin();

  if(ev!=NULL)
  {
    GetSystemTime(&stime);
    ev->window=(u32)win;
    ev->second=(u32)time(NULL);
    ev->millis=stime.wMilliseconds;
    ret=0;
  }

  debug_End();

  return(ret);
}


static void glw_CopyBck(struct glw_Window *win, RECT *rct)
{
  RECT rc;
  RECT *myrect=&rc;
  HDC hDC;
  Rect_t grct;

  debug_Begin();

  if(rct==NULL)
  {
    rc.left=rc.top=0;
    rc.right=win->wrect.right-win->wrect.left;
    rc.bottom=win->wrect.bottom-win->wrect.top;
  }
  else myrect=rct;
  if((win->flags&GLWF_SMART_REFRESH)==0)
  {
    glw_FillEvent(&win->conn->curr_event,win);
    grct.left=myrect->left;
    grct.top=myrect->top;
    grct.width=myrect->right-myrect->left;
    grct.height=myrect->bottom-myrect->top;
    win->conn->curr_event.event=GLWEV_DAMAGE;
    win->conn->curr_event.data=(u32)&grct;
    win->done|=gui_Event((u32)win->conn,&win->conn->curr_event);
  }
  else
  {
    hDC=GetDC(win->window);
    BitBlt(hDC,myrect->left,myrect->top,myrect->right-myrect->left,myrect->bottom-myrect->top,win->hdcMem,myrect->left,myrect->top,SRCCOPY);
    ReleaseDC(win->window,hDC);
  }

  debug_End();

}


static void glw_CopyBckIndirect(HWND hwnd,RECT *rct)
{
  struct glw_Window *win;
  Node_t *node;

  debug_Begin();

  if((node=glw_GetNode(hwnd))!=NULL)
  {
    if(NULL!=(win=(struct glw_Window *)list_GetNodeData(node))) glw_CopyBck(win,rct);
  }

  debug_End();

}


static int glw_ReadMessage(struct glw_Connection *conn)
{
  char header[GLW_HEADER_LENGTH];
  int rcv=0,r=0,ret=0;
  SYSTEMTIME stime;

  if(conn->completed==0)
  {
    // new message
    while(rcv<GLW_HEADER_LENGTH)
    {
      if((r=recv(conn->sd,header+rcv,GLW_HEADER_LENGTH-rcv,0))<=0)
      {
        if(WSAGetLastError()==WSAEWOULDBLOCK)
        {
          fd_set fdread;
          FD_ZERO(&fdread);
          FD_SET(conn->sd,&fdread);
          if((r=select(0,&fdread,NULL,NULL,NULL))==SOCKET_ERROR) break;
        }
        else
        {
          debug_Error("socket error: %d",WSAGetLastError());
          conn->cuser.quit=1;
          break;
        }
        if((r=recv(conn->sd,header+rcv,GLW_HEADER_LENGTH-rcv,0))<=0)
        {
          debug_Error("socket error (2): %d",WSAGetLastError());
          conn->cuser.quit=1;
          break;
        }
      }
      rcv+=r;
    }
    if(header[0]=='?')
    {
      conn->sockmsg.type=(int)header[1];
      conn->sockmsg.length=ntohl(*((u32 *)&header[2]));
      conn->sockmsg.id=ntohl(*((u32 *)&header[6]));
      conn->sockmsg.body=mem_malloc(conn->sockmsg.length-GLW_HEADER_LENGTH);
      conn->completed=GLW_HEADER_LENGTH;
//      printf("%s() legal message header: type=0x%02x id=%ld len=%ld\n",__FUNCTION__,(u8)conn->sockmsg.type,conn->sockmsg.id,conn->sockmsg.length);
      if(conn->sockmsg.body==NULL)
      {
        // HIBA!!
      }
    }
    else
    {
      // HIBA!!
      debug_Error("unknown message (%p) -> header=%02x type=%d",conn,(unsigned char)header[0],header[1]);
    }
  }
  else
  {
    // partial message
    r=recv( conn->sd,conn->sockmsg.body+conn->completed-GLW_HEADER_LENGTH,
            conn->sockmsg.length-conn->completed,0);
    if(r>0)
    {
      conn->completed+=r;
      if(conn->completed>=conn->sockmsg.length)
      {
        conn->completed=0;
        conn->curr_event.event=GLWEV_SOCKET;
        conn->curr_event.data=(u32)&conn->sockmsg;
        conn->curr_event.second=(u32)time(NULL);
        GetSystemTime(&stime);
        conn->curr_event.millis=stime.wMilliseconds;
      }
    }
  }
  return(ret);
}


LRESULT CALLBACK glw_StdWindowProc(HWND Window, UINT MessageType, WPARAM FirstParameter, LPARAM SecondParameter)
{
  PAINTSTRUCT ps;
  POINTS pnts;
  LRESULT ret=1L;
  struct glw_Window *win;
  struct glw_Connection *conn=NULL;

  debug_Begin();

  win=glw_GetGlwWindow(Window);
  if(win!=NULL)
  {
    conn=win->conn;
    if(win->user_state==GLWWS_OPENING||win->user_state==GLWWS_SKINNING) win=NULL;
  }
  if(conn!=NULL)
  {
    glw_FillEvent(&conn->curr_event,win);
    conn->curr_event.mousex=conn->mx;
    conn->curr_event.mousey=conn->my;
  }
  switch(MessageType)
  {
    case WM_ENTERSIZEMOVE:
    {
      if(win!=NULL)
      {
        win->state=1;
      }
      ret=0;
      break;
    }
    case WM_EXITSIZEMOVE:
    {
      if(win!=NULL)
      {
        if(win->state==2)
        {
          // last WM_SIZING message
          win->conn->curr_event.event=GLWEV_WINDOW;
          win->conn->curr_event.data=GLWEVD_SIZEEND;
          win->done|=gui_Event((u32)win->conn,&win->conn->curr_event);
        }
        else if(win->state==3)
        {
          // last WM_MOVING message
          win->conn->curr_event.event=GLWEV_WINDOW;
          win->conn->curr_event.data=GLWEVD_MOVEEND;
          win->done|=gui_Event((u32)win->conn,&win->conn->curr_event);
        }
        win->state=0;
      }
      ret=0;
      break;
    }
    case WM_QUIT:
    {
      if(conn!=NULL)
      {
        conn->curr_event.event=GLWEV_SYSTEM;
        conn->curr_event.data=GLWEVD_QUIT;
      }
      ret=0;
      break;
    }
    case WM_CLOSE:
    {
      DestroyWindow(Window);
      ret=0;
      break;
    }
    case WM_DESTROY:
    {
      ret=0;
      break;
    }
    case WM_ACTIVATE:
    {
      if(win!=NULL)
      {
        win->conn->curr_event.event=GLWEV_ACTIVATION;
        if(FirstParameter==WA_INACTIVE)
        {
          win->conn->curr_event.data=GLWEVD_INACTIVATE;
        }
        else
        {
          win->conn->curr_event.data=GLWEVD_ACTIVATE;
        }
        win->done|=gui_Event((u32)win->conn,&win->conn->curr_event);
      }
      ret=0;
      break;
    }
    case WM_MOUSEMOVE:
    {
      pnts=MAKEPOINTS(SecondParameter);
      if(conn!=NULL)
      {
        conn->mx=conn->curr_event.mousex=pnts.x;
        conn->my=conn->curr_event.mousey=pnts.y;
        conn->curr_event.event=GLWEV_MOUSEMOVE;
        conn->curr_event.data=GLWEVD_ABSOLUTE;
      }
      DefWindowProc(Window, MessageType, FirstParameter, SecondParameter);
      ret=0;
      break;
    }
    case WM_LBUTTONDOWN:
    {
      if(win!=NULL)
      {
        pnts=MAKEPOINTS(SecondParameter);
        win->conn->mx=win->conn->curr_event.mousex=pnts.x;
        win->conn->my=win->conn->curr_event.mousey=pnts.y;
        win->conn->curr_event.event=GLWEV_MOUSEBUTTONS;
        win->conn->curr_event.data=GLWEVD_LEFTDOWN;
      }
      ret=0;
      break;
    }
    case WM_LBUTTONUP:
    {
      if(win!=NULL)
      {
        pnts=MAKEPOINTS(SecondParameter);
        win->conn->mx=win->conn->curr_event.mousex=pnts.x;
        win->conn->my=win->conn->curr_event.mousey=pnts.y;
        win->conn->curr_event.event=GLWEV_MOUSEBUTTONS;
        win->conn->curr_event.data=GLWEVD_LEFTUP;
      }
      ret=0;
      break;
    }
    case WM_RBUTTONUP:
    {
      if(win!=NULL)
      {
        pnts=MAKEPOINTS(SecondParameter);
        win->conn->mx=win->conn->curr_event.mousex=pnts.x;
        win->conn->my=win->conn->curr_event.mousey=pnts.y;
        win->conn->curr_event.event=GLWEV_MOUSEBUTTONS;
        win->conn->curr_event.data=GLWEVD_RIGHTUP;
      }
      ret=0;
      break;
    }
    case WM_RBUTTONDOWN:
    {
      if(win!=NULL)
      {
        pnts=MAKEPOINTS(SecondParameter);
        win->conn->mx=win->conn->curr_event.mousex=pnts.x;
        win->conn->my=win->conn->curr_event.mousey=pnts.y;
        win->conn->curr_event.event=GLWEV_MOUSEBUTTONS;
        win->conn->curr_event.data=GLWEVD_RIGHTDOWN;
      }
      ret=0;
      break;
    }
    case WM_MBUTTONUP:
    {
      if(win!=NULL)
      {
        pnts=MAKEPOINTS(SecondParameter);
        win->conn->mx=win->conn->curr_event.mousex=pnts.x;
        win->conn->my=win->conn->curr_event.mousey=pnts.y;
        win->conn->curr_event.event=GLWEV_MOUSEBUTTONS;
        win->conn->curr_event.data=GLWEVD_MIDDLEUP;
      }
      ret=0;
      break;
    }
    case WM_MBUTTONDOWN:
    {
      if(win!=NULL)
      {
        pnts=MAKEPOINTS(SecondParameter);
        win->conn->mx=win->conn->curr_event.mousex=pnts.x;
        win->conn->my=win->conn->curr_event.mousey=pnts.y;
        win->conn->curr_event.event=GLWEV_MOUSEBUTTONS;
        win->conn->curr_event.data=GLWEVD_MIDDLEDOWN;
      }
      ret=0;
      break;
    }
    case WM_KEYDOWN:
    {
      if(win!=NULL)
      {
        win->conn->curr_event.event=GLWEV_KEYDOWN;
        win->conn->curr_event.data=FirstParameter;
      }
      ret=0;
      break;
    }
    case WM_KEYUP:
    {
      if(win!=NULL)
      {
        win->conn->curr_event.event=GLWEV_KEYUP;
        win->conn->curr_event.data=FirstParameter;
      }
      ret=0;
      break;
    }
    case WM_DISPLAYCHANGE:
    {
      HDC hDC;
      HWND dw;
      RECT rct;
      int oldX,oldY;

      if(win!=NULL)
      {
        oldX=buffsizeX;
        oldY=buffsizeY;
        dw=GetDesktopWindow();
        GetClientRect(dw,&rct);
        buffsizeX=rct.right;
        buffsizeY=rct.bottom;
        hDC=GetDC(dw);
        glw_DeleteBuffer(win);
        glw_CreateBuffer(win,hDC,buffsizeX,buffsizeY);
        ReleaseDC(dw,hDC);
        if((win->wrect.right-win->wrect.left)>buffsizeX||(win->wrect.bottom-win->wrect.top)>buffsizeY)
        {
          int w=min((win->wrect.right-win->wrect.left),buffsizeX);
          int h=min((win->wrect.bottom-win->wrect.top),buffsizeY);
          MoveWindow(Window,win->wrect.left,win->wrect.top,w,h,FALSE);
          win->wrect.right=win->wrect.left+w;
          win->wrect.bottom=win->wrect.top+h;
        }
        win->conn->curr_event.event=GLWEV_WINDOW;
        win->conn->curr_event.data=GLWEVD_REPAINT;
      }
      ret=0;
      break;
    }
    case WM_GETMINMAXINFO:
    {
      MINMAXINFO *sp=(MINMAXINFO *)SecondParameter;
      struct glw_Window *win;
      win=(struct glw_Window *)list_GetNodeData(glw_GetNode(Window));
      if(win!=NULL)
      {
        sp->ptMaxSize.x=buffsizeX;
        sp->ptMaxSize.y=buffsizeY;
        sp->ptMaxTrackSize.x=buffsizeX;
        sp->ptMaxTrackSize.y=buffsizeY;
        sp->ptMinTrackSize.x=win->minwidth;
        sp->ptMinTrackSize.y=win->minheight;
      }
      ret=0;
      break;
    }
    case WM_SIZING:
    {
      ret=0;
      break;
    }
    case WM_NCCALCSIZE:
    {
      if(win!=NULL)
      {
        memcpy(&win->wrect,(RECT *)SecondParameter,sizeof(RECT));
        if(win->state==1)
        {
          // first WM_SIZING message
          win->state=2;
          win->conn->curr_event.event=GLWEV_WINDOW;
          win->conn->curr_event.data=GLWEVD_SIZEBEGIN;
          win->done|=gui_Event((u32)win->conn,&win->conn->curr_event);
        }
        win->conn->curr_event.event=GLWEV_WINDOW;
        win->conn->curr_event.data=GLWEVD_SIZING;
        win->done|=gui_Event((u32)win->conn,&win->conn->curr_event);
      }
      ret=0;
      break;
    }
    case WM_MOVING:
    {
      if(win!=NULL)
      {
        memcpy(&win->wrect,(RECT *)SecondParameter,sizeof(RECT));
        if(win->state==1)
        {
          // first WM_MOVING message
          win->state=3;
          win->conn->curr_event.event=GLWEV_WINDOW;
          win->conn->curr_event.data=GLWEVD_MOVEBEGIN;
          win->done|=gui_Event((u32)win->conn,&win->conn->curr_event);
        }
        win->conn->curr_event.event=GLWEV_WINDOW;
        win->conn->curr_event.data=GLWEVD_MOVING;
        win->done|=gui_Event((u32)win->conn,&win->conn->curr_event);
      }
      ret=0;
      break;
    }
    case WM_TIMER:
    {
      if(win!=NULL)
      {
        win->conn->curr_event.event=GLWEV_TIMER;
        win->conn->curr_event.data=FirstParameter;
      }
      ret=0;
      break;
    }
    case WM_PAINT:
    {
      if(win!=NULL)
      {
        BeginPaint(Window,&ps);
        if(win->paint>0)
        {
          glw_CopyBckIndirect(Window,&ps.rcPaint);
        }
        else win->paint=1;
        EndPaint(Window,&ps);
      }
      ret=0;
      break;
    }
    case WM_NCPAINT:
    {
      ret=0;
      break;
    }
    case WM_SYSCOMMAND:
    {
      DefWindowProc(Window, MessageType, FirstParameter, SecondParameter);
      ret=0;
      break;
    }
    case WM_APP:
    {
      if(conn!=NULL) glw_ReadMessage(conn);
      ret=0;
      break;
    }
  }

  debug_End();

  return(ret);
}


/*---*/

u32 glw_htonl2(u32 firsttag, ...)
{
  return(glw_htonl2TL((tag *)&firsttag));
}
u32 glw_htonl2TL(tag *taglist)
{
  u32 value;
  u32 ret;

  debug_Begin();

  value=(u32 )tag_GetTagData(taglist,TAG_GLW_VALUE,0L);
  ret=htonl(value);

  debug_End();

    return((u32)ret);
}


u32 glw_ntohl2(u32 firsttag, ...)
{
  return(glw_ntohl2TL((tag *)&firsttag));
}
u32 glw_ntohl2TL(tag *taglist)
{
  u32 value;
  u32 ret;

  debug_Begin();

  value=(u32 )tag_GetTagData(taglist,TAG_GLW_VALUE,0L);
  ret=ntohl(value);

  debug_End();

    return((u32)ret);
}

u32 glw_htonl(u32 value)
{
  return(htonl(value));
}

u32 glw_ntohl(u32 value)
{
  return(ntohl(value));
}


int glw_Recv(u32 connection, u8 *buff, int bufflen)
{
  struct glw_Connection *conn=(struct glw_Connection *)connection;
  int ret=0;

  debug_Begin();

  if(conn!=NULL&&buff!=NULL&&bufflen>0)
  {
    ret=recv(conn->sd,buff,bufflen,0);
  }

  debug_End();

  return(ret);
}


int glw_Send(u32 connection, u8 *buff, int bufflen)
{
  struct glw_Connection *conn=(struct glw_Connection *)connection;
  int ret=0;

  debug_Begin();

  if(conn!=NULL&&buff!=NULL&&bufflen>0)
  {
    ret=send(conn->sd,buff,bufflen,0);
  }

  debug_End();

  return(ret);
}


int glw_SendMsg(u32 connection, u8 type, u32 id, u8 *buff, int bufflen)
{
  struct glw_Connection *conn=(struct glw_Connection *)connection;
  u8 header[GLW_HEADER_LENGTH];
  int mlen;

  debug_Begin();

  mlen=bufflen+GLW_HEADER_LENGTH;
  header[0]='?';
  header[1]=type;
  *((u32 *)&header[2])=htonl(mlen);
  *((u32 *)&header[6])=htonl(id);
  if(mlen<NET_WRITE_BUFFER_SIZE)
  {
    memcpy(conn->write_buffer,header,GLW_HEADER_LENGTH);
    if(bufflen>0) memcpy(conn->write_buffer+GLW_HEADER_LENGTH,buff,bufflen);
    send(conn->sd,conn->write_buffer,mlen,0);
  }
  else
  {
    send(conn->sd,header,GLW_HEADER_LENGTH,0);
    if(bufflen>0&&buff!=NULL) send(conn->sd,buff,bufflen,0);
  }

  debug_End();

  return(0);
}


#define SOCK_CLOSE_BUFSIZE  256

static DWORD WINAPI glw_Thread(void *sock)
{
  struct glw_Connection *conn;
  int NewBytes;
  char ReadBuffer[SOCK_CLOSE_BUFSIZE];
  Node_t *node;

  printf("server start (socket=%d)\n",(int)sock);

  mem_trace_checkpoint();

  if(NULL!=(conn=mem_calloc(1,sizeof(struct glw_Connection))))
  {
    if(NULL!=(conn->windowlist=list_CreateList()))
    {
      conn->sd=(SOCKET)sock;
      conn->cuser.quit=0;
      conn->win=NULL;
      conn->window_count=0;
      conn->termbyteorder=0;
      if(NULL!=(conn->write_buffer=mem_malloc(NET_WRITE_BUFFER_SIZE)))
      {
        if(NULL!=(conn->cuser.appname=net_CheckClient((u32)conn,&conn->byteorder)))
        {
          /* kapcsolodni a terminal-hoz! */
          debug_Message("ByteOrder: %d",conn->byteorder);
          net_Server((u32)conn);
        }
        if(shutdown(conn->sd,SD_SEND)!=SOCKET_ERROR)
        {
          while(1)
          {
            NewBytes=recv(conn->sd,ReadBuffer,SOCK_CLOSE_BUFSIZE,0);
            if(NewBytes==0||NewBytes==SOCKET_ERROR) break;
          }
          closesocket(conn->sd);
        }
      }
      while(NULL!=(node=list_GetNodeHead(conn->windowlist))) glw_CloseWindow(TAG_GLW_WINDOW,(u32)list_GetNodeData(node),TAG_DONE);
      list_DeleteList(conn->windowlist);
      if(conn->cuser.appname!=NULL) mem_free(conn->cuser.appname);
      mem_free(conn->write_buffer);
      mem_free(conn);
    }
  }

  mem_trace_report();

  printf("server end\n");

  return(0);
}


static void glw_Server(int port)
{
  char address[]="0.0.0.0";
  WSADATA wsaData;
  u_long InterfaceAddr;
  SOCKET ret=INVALID_SOCKET,sd,clisd;
  struct sockaddr_in Interface,Remote;
  int AddrSize=sizeof(Remote);
  HANDLE thandle=INVALID_HANDLE_VALUE;

  debug_Begin();

  quit=0;
  InterfaceAddr=inet_addr(address);
  if(WSAStartup(MAKEWORD(1,1),&wsaData)==0)
  {
    printf("Establishing the listener...\n");
    if(InterfaceAddr!=INADDR_NONE)
    {
      sd=socket(AF_INET,SOCK_STREAM,0);
      if(sd!=INVALID_SOCKET)
      {
        Interface.sin_family=AF_INET;
        Interface.sin_addr.s_addr=InterfaceAddr;
        Interface.sin_port=htons(port);
        if(bind(sd,(struct sockaddr *)&Interface,sizeof(struct sockaddr_in))!=SOCKET_ERROR)
        {
          listen(sd,SOMAXCONN);
          ret=sd;
        }
      }
    }
    if(ret!=INVALID_SOCKET)
    {
      sd=ret;
      printf("Waiting for connections...\n");
      while(quit==0)
      {
        clisd=accept(sd,(struct sockaddr *)&Remote,&AddrSize);
        if(clisd!=INVALID_SOCKET)
        {
          printf("Accepted (on socket %d) %lx connection from %s:%d .\n",clisd,Remote.sin_addr.s_addr,inet_ntoa(Remote.sin_addr),ntohs(Remote.sin_port));
          thandle=CreateThread(0,0,glw_Thread,(void *)clisd,0,NULL);
          quit=1;
        }
      }
      // itt majd egy listaba tesszuk a futo thread-eket es az osszesre varnunk kell!
      if(INVALID_HANDLE_VALUE!=thandle) WaitForSingleObject(thandle,-1);
    }
    WSACleanup();
  }

  debug_End();
}


// Main Function
int WINAPI WinMain(HINSTANCE Instance, HINSTANCE PreviousInstance, LPSTR CommandLine, int CommandShow)
{
  RECT rct3vv;
  Node_t *node;
  OSVERSIONINFO ovi;

  debug_Begin();

/*
  { int i;
    for(i=0;i<sizeof(call_vector);i++) call_vector[i]=(u32 (*)(tag *))bases_Unimplemented;
  }
*/

//Initialize call vector BEGIN - put this into the init function of this module
  call_vector[GLW_STARTMOUSETRACKING-GLW_FUNCBASE]=glw_StartMouseTrackingTL;
  call_vector[GLW_STOPMOUSETRACKING-GLW_FUNCBASE]=glw_StopMouseTrackingTL;
  call_vector[GLW_DRAGWINDOW-GLW_FUNCBASE]=glw_DragWindowTL;
  call_vector[GLW_RESIZEWINDOW-GLW_FUNCBASE]=glw_ResizeWindowTL;
  call_vector[GLW_SETCOLOR-GLW_FUNCBASE]=glw_SetColorTL;
  call_vector[GLW_SETBACKGROUND-GLW_FUNCBASE]=glw_SetBackgroundTL;
  call_vector[GLW_DRAWLINE-GLW_FUNCBASE]=glw_DrawLineTL;
  call_vector[GLW_DRAWRECT-GLW_FUNCBASE]=glw_DrawRectTL;
  call_vector[GLW_DRAWFILLEDRECT-GLW_FUNCBASE]=glw_DrawFilledRectTL;
  call_vector[GLW_DRAWPIXEL-GLW_FUNCBASE]=glw_DrawPixelTL;
  call_vector[GLW_OPENFONT-GLW_FUNCBASE]=glw_OpenFontTL;
  call_vector[GLW_CLOSEFONT-GLW_FUNCBASE]=glw_CloseFontTL;
  call_vector[GLW_DRAWTEXT-GLW_FUNCBASE]=glw_DrawTextTL;
  call_vector[GLW_GETFONTSIZE-GLW_FUNCBASE]=glw_GetFontSizeTL;
  call_vector[GLW_GETTEXTLENGTH-GLW_FUNCBASE]=glw_GetTextLengthTL;
  call_vector[GLW_PUTIMAGE-GLW_FUNCBASE]=glw_PutImageTL;
  call_vector[GLW_GETSCREENDIMENSIONS-GLW_FUNCBASE]=glw_GetScreenDimensionsTL;
  call_vector[GLW_TIMERSTART-GLW_FUNCBASE]=glw_TimerStartTL;
  call_vector[GLW_TIMERCANCEL-GLW_FUNCBASE]=glw_TimerCancelTL;
  call_vector[GLW_GETTIME-GLW_FUNCBASE]=glw_GetTimeTL;
  call_vector[GLW_HTONL2-GLW_FUNCBASE]=glw_htonl2TL;
  call_vector[GLW_NTOHL2-GLW_FUNCBASE]=glw_ntohl2TL;
  call_vector[GLW_SETWINDOWDIMENSIONS-GLW_FUNCBASE]=glw_SetWindowDimensionsTL;
  call_vector[GLW_GETWINDOWDIMENSIONS-GLW_FUNCBASE]=glw_GetWindowDimensionsTL;
  call_vector[GLW_SETPOINTER-GLW_FUNCBASE]=glw_SetPointerTL;
  call_vector[GLW_SETWINDOWTRANSPARENCY-GLW_FUNCBASE]=glw_SetWindowTransparencyTL;
  call_vector[GLW_SLEEP-GLW_FUNCBASE]=glw_SleepTL;
  bases_modules.glw_Call=glw_Call;
  bases_modules.glw_CallTL=glw_CallTL;
//Initialize call vector END

  // detect windows version
  ovi.dwOSVersionInfoSize=sizeof(ovi);
  GetVersionEx(&ovi);
  // wv=0   3.1
  // wv=1   95
  // wv=2   98
  // wv=3   NT4
  // wv=4   2k
  // wv=5   xp
  if(ovi.dwPlatformId==VER_PLATFORM_WIN32_NT&&ovi.dwMajorVersion>=5) wv=4;            // 2k or xp
  else if(ovi.dwPlatformId==VER_PLATFORM_WIN32_NT&&ovi.dwMajorVersion>=4) wv=3;       // NT4
  else if(ovi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS&&ovi.dwMajorVersion>=4) wv=2;  // 98
  else if(ovi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS&&ovi.dwMajorVersion>=3) wv=1;  // 95
  else wv=0;
  sInstance=Instance;
  sCommandShow=CommandShow;
  user32_DLL=LoadLibrary("user32");
  if(NULL!=(windowlist=list_CreateList()))
  {
    if(NULL!=(fontfacelist=list_CreateList()))
    {
      if(0==(glw_LoadFontFaces(fontfacelist)))
      {
        if(NULL!=(fontlist=list_CreateList()))
        {
          WindowClass.cbSize = sizeof(WNDCLASSEX);
          WindowClass.style = 0;
          WindowClass.lpfnWndProc = glw_StdWindowProc;
          WindowClass.cbClsExtra = 0;
          WindowClass.cbWndExtra = 0;
          WindowClass.hInstance = sInstance;
          WindowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
          WindowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
          WindowClass.hbrBackground = GetStockObject(WHITE_BRUSH);
          WindowClass.lpszMenuName = NULL;
          WindowClass.lpszClassName = "glw_StdWindowClass";
          WindowClass.hIconSm = NULL;
          if(RegisterClassEx(&WindowClass)!=0)
          {
            GetClientRect(GetDesktopWindow(),&rct3vv);
            buffsizeX=rct3vv.right;
            buffsizeY=rct3vv.bottom;
            workDC=CreateCompatibleDC(NULL);

            gui_Init();
            debug_Message("Server is up and running.");
            glw_Server(net_GetPort());
            gui_CleanUp();

            while(NULL!=(node=list_GetNodeHead(windowlist))) glw_CloseWindow(TAG_GLW_WINDOW,(u32)list_GetNodeData(node),TAG_DONE);
          }
          while(NULL!=(node=list_GetNodeHead(fontlist))) glw_CloseFont(TAG_GLW_FONT,(u32)list_GetNodeData(node),TAG_DONE);
          list_DeleteList(fontlist);
          if(NULL!=workDC) DeleteDC(workDC);
        }
        glw_UnloadFontFaces(fontfacelist);
        fontfacelist=NULL;
      }
    }
    list_DeleteList(windowlist);
  }
  FreeLibrary(user32_DLL);

  mem_trace_report();

  debug_End();

  return(0L);
}


/*----*/

//SYS
u32 glw_OpenWindow(u32 firsttag, ...)
{
  return(glw_OpenWindowTL((tag *)&firsttag));
}
u32 glw_OpenWindowTL(tag *taglist)
{
  struct glw_Connection *conn;
  Rect_t *rect;
  u32 flags;
  u32 userdata;

  HWND dw;
  HDC hDC;
  struct glw_Window *win=NULL;
  Node_t *node,*node2;

  debug_Begin();

  conn=(struct glw_Connection *)tag_GetTagData(taglist,TAG_GLW_CONN,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_GLW_RECT,0L);
  flags=(u32)tag_GetTagData(taglist,TAG_GLW_FLAGS,0L);
  userdata=(u32)tag_GetTagData(taglist,TAG_GLW_USERDATA,0L);

  if(NULL!=(node=list_CreateNode()))
  {
    if(NULL!=(node2=list_CreateNode()))
    {
      if(NULL!=(win=mem_malloc(sizeof(struct glw_Window))))
      {
        win->user_state=GLWWS_OPENING;
        win->conn=conn;
        win->flags=flags;
        win->userdata=userdata;
        list_SetNodeData(node,win);
        list_SetNodeData(node2,win);
        list_InsertNodeTail(windowlist,node);
        list_InsertNodeTail(conn->windowlist,node2);
        debug_Message("open %dx%d window",rect->width,rect->height);
        if((dw=CreateWindowEx(
            (((flags&~GLWF_MAYBE_SMALL)!=0)?WS_EX_OVERLAPPEDWINDOW:WS_EX_TOOLWINDOW),
            "glw_StdWindowClass",
            NULL,
            WS_OVERLAPPED|WS_VISIBLE,
            rect->left, rect->top, rect->width, rect->height,
            NULL,
            NULL,
            sInstance,
            NULL))!=NULL)
        {
          if(conn->window_count==0)
          {
            WSAAsyncSelect(conn->sd,dw,WM_APP,FD_READ);
            conn->win=win;
          }
          win->window=dw;
          ShowWindow(win->window,sCommandShow);
          dw=GetDesktopWindow();
          hDC=GetDC(dw);
          glw_CreateBuffer(win,hDC,buffsizeX,buffsizeY);
          ReleaseDC(dw,hDC);
          GetWindowRect(win->window,&win->wrect);
          glw_ClearWindow(TAG_GLW_WINDOW,(u32)win,TAG_DONE);
          SetCursor(LoadCursor(NULL,IDC_ARROW));
          conn->window_count++;
          win->minwidth=0;
          win->minheight=0;
          win->done=0;
//          glw_SetWindowTransparency(TAG_GLW_WINDOW,win,TAG_GLW_PERCENT,70,TAG_DONE);
        }
      }
    }
  }

  debug_End();

  return((u32)win);
}


u32 glw_SetWindowState(u32 firsttag, ...)
{
  return(glw_SetWindowStateTL((tag *)&firsttag));
}
u32 glw_SetWindowStateTL(tag *taglist)
{
  struct glw_Window *win;
  int state;

  int ret=0;

  debug_Begin();

  win=(struct glw_Window *)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  state=(int)tag_GetTagData(taglist,TAG_GLW_STATE,0L);

  if(win!=NULL)
  {
    ret=win->user_state;
    win->user_state=state;
  }

  debug_End();

  return((u32)ret);
}


u32 glw_CloseWindow(u32 firsttag, ...)
{
  return(glw_CloseWindowTL((tag *)&firsttag));
}
u32 glw_CloseWindowTL(tag *taglist)
{
  struct glw_Window *win;
  Node_t *node;

  debug_Begin();

  win=(struct glw_Window *)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);

  if(win!=NULL)
  {
    node=glw_GetNode(win->window);
    list_SetNodeData(node,NULL);
    list_RemoveNode(windowlist,node);
    list_DeleteNode(node);

    node=glw_GetNode2(win->conn,win->window);
    list_SetNodeData(node,NULL);
    list_RemoveNode(win->conn->windowlist,node);
    list_DeleteNode(node);

    SetWindowRgn(win->window,NULL,FALSE);
    DestroyWindow(win->window);
    glw_DeleteBuffer(win);
    win->conn->window_count--;
    if(win->conn->win==win)
    {
      WSAAsyncSelect(win->conn->sd,win->window,0,0);
      if(NULL!=(node=list_GetNodeHead(win->conn->windowlist)))
      {
        struct glw_Window *w2;
        if(NULL!=(w2=list_GetNodeData(node)))
        {
          win->conn->win=w2;
          WSAAsyncSelect(win->conn->sd,w2->window,WM_APP,FD_READ);
        }
      }
    }
    mem_free(win);
  }

  debug_End();

  return(0L);
}


u32 glw_GetWindowUserdata(u32 firsttag, ...)
{
  return(glw_GetWindowUserdataTL((tag *)&firsttag));
}
u32 glw_GetWindowUserdataTL(tag *taglist)
{
  struct glw_Window *win;

  u32 ret;

  debug_Begin();

  win=(struct glw_Window *)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);

  ret=(win==NULL?0L:win->userdata);

  debug_End();

  return(ret);
}


u32 glw_SetWindowLimits(u32 firsttag, ...)
{
  return(glw_SetWindowLimitsTL((tag *)&firsttag));
}
u32 glw_SetWindowLimitsTL(tag *taglist)
{
  struct glw_Window *win;
  int minwidth;
  int minheight;
  int maxwidth;
  int maxheight;

  debug_Begin();

  win=(struct glw_Window *)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  minwidth=(int)tag_GetTagData(taglist,TAG_GLW_MINWIDTH,0L);
  minheight=(int)tag_GetTagData(taglist,TAG_GLW_MINHEIGHT,0L);
  maxwidth=(int)tag_GetTagData(taglist,TAG_GLW_MAXWIDTH,0L);
  maxheight=(int)tag_GetTagData(taglist,TAG_GLW_MAXHEIGHT,0L);

  if(win!=NULL)
  {
    win->minwidth=minwidth;
    win->minheight=minheight;
    win->maxwidth=maxwidth;
    win->maxheight=maxheight;
  }

  debug_End();

  return(0L);
}


u32 glw_SetWindowTransparency(u32 firsttag, ...)
{
  return(glw_SetWindowTransparencyTL((tag *)&firsttag));
}
u32 glw_SetWindowTransparencyTL(tag *taglist)
{
  u32 window;
  int percent;

  u32 ret=~0L;
  struct glw_Window *win;

  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  percent=(int)tag_GetTagData(taglist,TAG_GLW_PERCENT,0L);

  win=(struct glw_Window *)window;
  if(win!=NULL&&percent>=0&&percent<=100)
  {
    if(0==glw_WindowTransparent(win,percent)) ret=0L;
  }

  debug_End();

  return(ret);
}


u32 glw_SetWindowDimensions(u32 firsttag, ...)
{
  return(glw_SetWindowDimensionsTL((tag *)&firsttag));
}
u32 glw_SetWindowDimensionsTL(tag *taglist)
{
  u32 window;
  Rect_t *rect;

  u32 ret=~0L;
  struct glw_Window *win;

  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_GLW_RECT,0L);

  win=(struct glw_Window *)window;
  if(win!=NULL)
  {
    GetWindowRect(win->window,&win->wrect);
    win->wrect.right=win->wrect.left+rect->width;
    win->wrect.bottom=win->wrect.top+rect->height;
//    SetWindowPos(win->window,NULL,0,0,win->wrect.right-win->wrect.left,win->wrect.bottom-win->wrect.top,SWP_NOMOVE|SWP_NOZORDER);
    debug_Message("%ld,%ld (%ldx%ld)",win->wrect.left,win->wrect.top,win->wrect.right-win->wrect.left,win->wrect.bottom-win->wrect.top);
    MoveWindow(win->window,win->wrect.left,win->wrect.top,win->wrect.right-win->wrect.left+0,win->wrect.bottom-win->wrect.top+0,FALSE);
    debug_Message("after");
    ret=0L;
  }

  debug_End();

  return(ret);
}


u32 glw_GetWindowDimensions(u32 firsttag, ...)
{
  return(glw_GetWindowDimensionsTL((tag *)&firsttag));
}
u32 glw_GetWindowDimensionsTL(tag *taglist)
{
  u32 window;
  Rect_t *rect;

  struct glw_Window *win;

  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_GLW_RECT,0L);

  win=(struct glw_Window *)window;
  if(win!=NULL)
  {
//    GetWindowRect(win->window,&win->wrect);
    rect->left=win->wrect.left;
    rect->top=win->wrect.top;
    rect->width=win->wrect.right-win->wrect.left;
    rect->height=win->wrect.bottom-win->wrect.top;
  }

  debug_End();

  return(0L);
}


u32 glw_SetPointer(u32 firsttag, ...)
{
  return(glw_SetPointerTL((tag *)&firsttag));
}
#define CRSR_MAX  4
u32 glw_SetPointerTL(tag *taglist)
{
//  u32 window;
  int pnt;

static LPCTSTR cursors[]=
{
  IDC_ARROW,
  IDC_SIZENESW,
  IDC_SIZENS,
  IDC_SIZENWSE,
  IDC_SIZEWE
};

  debug_Begin();

//  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  pnt=(int)tag_GetTagData(taglist,TAG_GLW_POINTER,0L);

  if(pnt>CRSR_MAX||pnt<0) pnt=0;
/*
  hOld=SetCursor(LoadCursor(NULL,IDC_WAIT));
  IDC_ARROW
  IDC_SIZENESW : /
  IDC_SIZENS   : |
  IDC_SIZENWSE : \
  IDC_SIZEWE   : -
  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wcepoint/htm/_wcesdk_win32_loadcursor.asp
*/
  SetCursor(LoadCursor(NULL,cursors[pnt]));

  debug_End();

  return(0L);
}


u32 glw_RefreshWindow(u32 firsttag, ...)
{
  return(glw_RefreshWindowTL((tag *)&firsttag));
}
u32 glw_RefreshWindowTL(tag *taglist)
{
  struct glw_Window *win;

  debug_Begin();

  win=(struct glw_Window *)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);

  if(win!=NULL&&(win->flags&GLWF_SMART_REFRESH)!=0) glw_CopyBck(win,NULL);

  debug_End();

  return(0L);
}


u32 glw_RefreshWindowPartial(u32 firsttag, ...)
{
  return(glw_RefreshWindowPartialTL((tag *)&firsttag));
}
u32 glw_RefreshWindowPartialTL(tag *taglist)
{
  struct glw_Window *win;
  Rect_t *rect;

  RECT rct;

  debug_Begin();

  win=(struct glw_Window *)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_GLW_RECT,0L);

  if(rect!=NULL&&win!=NULL&&(win->flags&GLWF_SMART_REFRESH)!=0)
  {
    rct.left=rect->left;
    rct.top=rect->top;
    rct.right=rect->left+rect->width;
    rct.bottom=rect->top+rect->height;
    glw_CopyBck(win,&rct);
  }

  debug_End();

  return(0L);
}


u32 glw_StartMouseTracking(u32 firsttag, ...)
{
  return(glw_StartMouseTrackingTL((tag *)&firsttag));
}
u32 glw_StartMouseTrackingTL(tag *taglist)
{
  u32 window;

  struct glw_Window *win;

  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);

  win=(struct glw_Window *)window;

  if(win!=NULL) SetCapture(win->window);

  debug_End();

  return(0L);
}


u32 glw_StopMouseTracking(u32 firsttag, ...)
{
  return(glw_StopMouseTrackingTL((tag *)&firsttag));
}
u32 glw_StopMouseTrackingTL(tag *taglist)
{
  struct glw_Window *win;

  u32 ret=~0L;

  debug_Begin();

  win=(struct glw_Window *)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);


  debug_Begin();

  if(win!=NULL)
  {
    ReleaseCapture();
    ret=0L;
  }

  debug_End();

  return(ret);
}


u32 glw_DragWindow(u32 firsttag, ...)
{
  return(glw_DragWindowTL((tag *)&firsttag));
}
u32 glw_DragWindowTL(tag *taglist)
{
  u32 window;

  struct glw_Window *win;


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);

  win=(struct glw_Window *)window;

  if(window!=0L) SendMessage(win->window,WM_SYSCOMMAND,SC_MOVE|0x0002,0);

  debug_End();

  return((u32)0);
}


u32 glw_ResizeWindow(u32 firsttag, ...)
{
  return(glw_ResizeWindowTL((tag *)&firsttag));
}
u32 glw_ResizeWindowTL(tag *taglist)
{
  u32 window;
  int type;

  struct glw_Window *win;


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  type=(int )tag_GetTagData(taglist,TAG_GLW_TYPE,0L);

  win=(struct glw_Window *)window;

  if(window!=0L) SendMessage(win->window,WM_SYSCOMMAND,SC_SIZE|type,0);

  debug_End();

  return((u32)0);
}


// graphics primitives
u32 glw_SetColor(u32 firsttag, ...)
{
  return(glw_SetColorTL((tag *)&firsttag));
}
u32 glw_SetColorTL(tag *taglist)
{
  u32 window;
  u32 rgb;

  struct glw_Window *win;
  u32 ret;


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  rgb=(u32 )tag_GetTagData(taglist,TAG_GLW_RGB,0L);

  win=(struct glw_Window *)window;

  ret=win->fgrgb;
  win->fgrgb=rgb;
  if(rgb!=GLW_TRANSPARENT)
  {
    win->fgcol=RGB(rgb>>16,(rgb>>8)&0xff,rgb&0xff);
    DeleteObject(win->fgbrush);
    win->fgbrush=CreateSolidBrush(win->fgcol);
    DeleteObject(win->pen);
    win->logbrush.lbColor=win->fgcol;
    win->pen=ExtCreatePen(PS_COSMETIC|PS_SOLID,1,&win->logbrush,0,NULL);
  }

  debug_End();

  return((u32)ret);
}


u32 glw_SetBackground(u32 firsttag, ...)
{
  return(glw_SetBackgroundTL((tag *)&firsttag));
}
u32 glw_SetBackgroundTL(tag *taglist)
{
  u32 window;
  u32 rgb;

  struct glw_Window *win;
  u32 ret;


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  rgb=(u32 )tag_GetTagData(taglist,TAG_GLW_RGB,0L);

  win=(struct glw_Window *)window;

  ret=win->bgrgb;
  win->bgrgb=rgb;
  if(rgb!=GLW_TRANSPARENT)
  {
    win->bgcol=RGB(rgb>>16,(rgb>>8)&0xff,rgb&0xff);
    DeleteObject(win->bgbrush);
    win->bgbrush=CreateSolidBrush(win->bgcol);
  }

  debug_End();

  return((u32)ret);
}


u32 glw_DrawLine(u32 firsttag, ...)
{
  return(glw_DrawLineTL((tag *)&firsttag));
}
u32 glw_DrawLineTL(tag *taglist)
{
  u32 window;
  int x1;
  int y1;
  int x2;
  int y2;

  struct glw_Window *win;
  HPEN hbpOld;


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  x1=(int )tag_GetTagData(taglist,TAG_GLW_X1,0L);
  y1=(int )tag_GetTagData(taglist,TAG_GLW_Y1,0L);
  x2=(int )tag_GetTagData(taglist,TAG_GLW_X2,0L);
  y2=(int )tag_GetTagData(taglist,TAG_GLW_Y2,0L);

  win=(struct glw_Window *)window;

  if(win->fgrgb!=GLW_TRANSPARENT)
  {
    hbpOld=SelectObject(win->hdcMem,win->pen);
    MoveToEx(win->hdcMem,x1,y1,NULL);
    LineTo(win->hdcMem,x2,y2);
    SelectObject(win->hdcMem,hbpOld);
  }

  debug_End();

  return((u32)0);
}


u32 glw_DrawRect(u32 firsttag, ...)
{
  return(glw_DrawRectTL((tag *)&firsttag));
}
u32 glw_DrawRectTL(tag *taglist)
{
  u32 window;
  int left;
  int top;
  int width;
  int height;

  struct glw_Window *win;
  HPEN hbpOld;


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  left=(int )tag_GetTagData(taglist,TAG_GLW_LEFT,0L);
  top=(int )tag_GetTagData(taglist,TAG_GLW_TOP,0L);
  width=(int )tag_GetTagData(taglist,TAG_GLW_WIDTH,0L);
  height=(int )tag_GetTagData(taglist,TAG_GLW_HEIGHT,0L);

  win=(struct glw_Window *)window;

  if(win->fgrgb!=GLW_TRANSPARENT)
  {
    hbpOld=SelectObject(win->hdcMem,win->pen);
    MoveToEx(win->hdcMem,left,top,NULL);
    LineTo(win->hdcMem,left+width,top);
    LineTo(win->hdcMem,left+width,top+height);
    LineTo(win->hdcMem,left,top+height);
    LineTo(win->hdcMem,left,top);
    SelectObject(win->hdcMem,hbpOld);
  }

  debug_End();

  return((u32)0);
}


u32 glw_DrawFilledRect(u32 firsttag, ...)
{
  return(glw_DrawFilledRectTL((tag *)&firsttag));
}
u32 glw_DrawFilledRectTL(tag *taglist)
{
  u32 window;
  int left;
  int top;
  int width;
  int height;

  struct glw_Window *win;
  RECT rc;


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  left=(int )tag_GetTagData(taglist,TAG_GLW_LEFT,0L);
  top=(int )tag_GetTagData(taglist,TAG_GLW_TOP,0L);
  width=(int )tag_GetTagData(taglist,TAG_GLW_WIDTH,0L);
  height=(int )tag_GetTagData(taglist,TAG_GLW_HEIGHT,0L);

  win=(struct glw_Window *)window;

  if(win->fgrgb!=GLW_TRANSPARENT)
  {
    rc.left=left;
    rc.top=top;
    rc.bottom=top+height;
    rc.right=left+width;
    FillRect(win->hdcMem,&rc,win->fgbrush);
  }

  debug_End();

  return((u32)0);
}


u32 glw_DrawPixel(u32 firsttag, ...)
{
  return(glw_DrawPixelTL((tag *)&firsttag));
}
u32 glw_DrawPixelTL(tag *taglist)
{
  u32 window;
  int x;
  int y;

  struct glw_Window *win;


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  x=(int )tag_GetTagData(taglist,TAG_GLW_X,0L);
  y=(int )tag_GetTagData(taglist,TAG_GLW_Y,0L);

  win=(struct glw_Window *)window;

  if(win->fgrgb!=GLW_TRANSPARENT)
  {
    SetPixel(win->hdcMem,x,y,win->fgcol);
  }

  debug_End();

  return((u32)0);
}



// event handling
int glw_MainLoop(u32 connection, u32 userdata, u32 mask)
{
  struct glw_Connection *conn=(struct glw_Connection *)connection;
  struct glw_Window *win=NULL;
  MSG Message;
  int r=1;

  debug_Begin();

  if(conn->cuser.quit==0)
  {
    conn->level++;
    conn->curr_event.userdata=userdata;
    conn->curr_event.event=GLWEV_SOCKET;
    conn->curr_event.data=0;
    if(0==(gui_Event((u32)conn,&conn->curr_event)))
    {
      while(r!=0)
      {
        conn->curr_event.mask=mask;
        conn->curr_event.userdata=userdata;
        if(conn->window_count>0)
        {
          win=NULL;
          conn->curr_event.event=GLWEV_NOEVENT;
          conn->curr_event.data=0;
          while(conn->curr_event.event==GLWEV_NOEVENT)
          {
            r=GetMessage(&Message,NULL,0,0); // wait for message
            win=glw_GetGlwWindow(Message.hwnd);
            glw_FillEvent(&conn->curr_event,win);
            TranslateMessage(&Message);      // keycode conversion
            DispatchMessage(&Message);       // call StdWindowProc() (retval==StdWindowProc's retval)
          }
          if(win!=NULL)
          {
            win->done|=gui_Event((u32)conn,&win->conn->curr_event);
//              if(win->done<0||r==0) conn->done=1;
            if(win->done!=0)
            {
              break;
            }
          }
          if(conn->completed<0) break;
        }
        else
        {
          conn->curr_event.event=GLWEV_NOEVENT;
          conn->curr_event.window=0L;
          conn->curr_event.mousex=conn->curr_event.mousey=0;
          glw_ReadMessage(conn);
          if(conn->curr_event.event!=GLWEV_NOEVENT)
          {
            if(0!=gui_Event((u32)conn,&conn->curr_event)) break;
          }
          if(conn->completed<0) break;
        }
      }
    }
    if(win!=NULL) win->done=0;
    conn->level--;
  }
  debug_End();

  return(0);
}


// font handling
u32 glw_OpenFont(u32 firsttag, ...)
{
  return(glw_OpenFontTL((tag *)&firsttag));
}
u32 glw_OpenFontTL(tag *taglist)
{
  struct glw_Connection *conn;
  char *face;
  int size;
  u32 style;

  struct glw_FontFace *fface;
  struct glw_Font *font=NULL;
  Node_t *node;

  debug_Begin();

  conn=(struct glw_Connection *)tag_GetTagData(taglist,TAG_GLW_CONN,0L);
  face=(char *)tag_GetTagData(taglist,TAG_GLW_FACE,0L);
  size=(int )tag_GetTagData(taglist,TAG_GLW_SIZE,0L);
  style=(u32 )tag_GetTagData(taglist,TAG_GLW_STYLE,0L);

  if(conn!=NULL)
  {
    if(NULL!=(fface=glw_GetFaceWinName(fontfacelist,face)))
    {
      // search an already opened one
      for(node=list_GetNodeHead(fontlist);node!=NULL;node=list_GetNodeNext(fontlist,node))
      {
        if(NULL!=(font=(struct glw_Font *)list_GetNodeData(node)))
        {
          if(font->conn==conn&&font->face==fface&&(font->size==size||font->size==0)&&font->style==style) break;
          font=NULL;
        }
      }
      if(font==NULL)
      {
        if(NULL!=(font=mem_malloc(sizeof(struct glw_Font)))&&NULL!=(node=list_CreateNode()))
        {
          font->conn=conn;
          font->face=fface;
          font->size=size;
          font->style=style;
          font->counter=1;
          font->node=node;
          font->handle=CreateFont(size,0,0,0,((style&GLWFS_BOLD)==0?400:700),
                                  ((style&GLWFS_ITALIC)==0?FALSE:TRUE),
                                  ((style&GLWFS_UNDERLINE)==0?FALSE:TRUE),FALSE,
                                  DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,
                                  ANTIALIASED_QUALITY,DEFAULT_PITCH|FF_DONTCARE,(LPCTSTR)fface->win_name);
          if(font->handle!=NULL)
          {
            list_SetNodeData(node,font);
            list_InsertNodeTail(fontlist,node);
          }
          else
          {
            glw_CloseFont(TAG_GLW_FONT,(u32)font,TAG_DONE);
            font=NULL;
            list_DeleteNode(node);
          }
        }
      }
      else
      {
        font->counter++;
      }
    }
  }

  debug_End();

  return((u32)(u32)font);
}


u32 glw_CloseFont(u32 firsttag, ...)
{
  return(glw_CloseFontTL((tag *)&firsttag));
}
u32 glw_CloseFontTL(tag *taglist)
{
  u32 font;

  struct glw_Font *fnt;

  debug_Begin();

  font=(u32 )tag_GetTagData(taglist,TAG_GLW_FONT,0L);
  fnt=(struct glw_Font *)font;

  if(fnt!=NULL)
  {
    if(--fnt->counter<=0)
    {
      if(fnt->handle!=NULL)
      {
        DeleteObject(fnt->handle);
        fnt->handle=NULL;
        list_RemoveNode(fontlist,fnt->node);
        list_SetNodeData(fnt->node,NULL);
        list_DeleteNode(fnt->node);
      }
      mem_free(fnt);
    }
  }

  debug_End();

  return(0L);
}

// text drawing
u32 glw_DrawText(u32 firsttag, ...)
{
  return(glw_DrawTextTL((tag *)&firsttag));
}
u32 glw_DrawTextTL(tag *taglist)
{
  u32 window;
  Rect_t *cliprect;
  u32 font;
  char *text;
  u32 flags;

  struct glw_Window *win;
  struct glw_Font *fnt;
  RECT rct;
  HFONT oldfont;
  int left,top;
  u32 alignH=TA_LEFT;


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  cliprect=(Rect_t *)tag_GetTagData(taglist,TAG_GLW_CLIPRECT,0L);
  font=(u32 )tag_GetTagData(taglist,TAG_GLW_FONT,0L);
  text=(char *)tag_GetTagData(taglist,TAG_GLW_TEXT,0L);
  flags=(u32 )tag_GetTagData(taglist,TAG_GLW_FLAGS,0L);

  win=(struct glw_Window *)window;
  fnt=(struct glw_Font *)font;

  if(win->fgrgb!=GLW_TRANSPARENT&&fnt!=NULL)
  {
    rct.left=cliprect->left;
    rct.top=cliprect->top;
    rct.right=cliprect->left+cliprect->width-1;
    rct.bottom=cliprect->top+cliprect->height-1;
    oldfont=SelectObject(win->hdcMem,fnt->handle);
    SetTextColor(win->hdcMem,win->fgcol);
    left=cliprect->left;
    top=cliprect->top;
    if((flags&GLWFA_ALIGN_RIGHT)!=0)
    {
      left=cliprect->left+cliprect->width;
      alignH=TA_RIGHT;
    }
    if((flags&GLWFA_ALIGN_CENTER)!=0)
    {
      left+=cliprect->width>>1;
      alignH=TA_CENTER;
    }
    if((flags&GLWFA_VALIGN_BOTTOM)!=0)
    {
      top+=cliprect->height-fnt->size;
    }
    if((flags&GLWFA_VALIGN_CENTER)!=0)
    {
      top+=(cliprect->height-fnt->size)>>1;
    }
    SetTextAlign(win->hdcMem,alignH|TA_TOP);
//  SetBkColor(win->hdcMem,win->bgcol);
    SetBkMode(win->hdcMem,TRANSPARENT);
//  DrawTextEx(win->hdcMem,text,-1,&rct,DT_LEFT|DT_NOPREFIX|DT_SINGLELINE|DT_VCENTER,NULL);
    ExtTextOut(win->hdcMem,left,top,ETO_CLIPPED,&rct,text,strlen(text),NULL);
    SelectObject(win->hdcMem,oldfont);
  }

  debug_End();

  return((u32)0);
};


u32 glw_GetFontSize(u32 firsttag, ...)
{
  return(glw_GetFontSizeTL((tag *)&firsttag));
}
u32 glw_GetFontSizeTL(tag *taglist)
{
  u32 font;

  int ret=-1;
  struct glw_Font *fnt;


  debug_Begin();

  font=(u32 )tag_GetTagData(taglist,TAG_GLW_FONT,0L);

  fnt=(struct glw_Font *)font;

  if(fnt!=NULL) ret=fnt->size;

  debug_End();

  return((u32)ret);
}


u32 glw_GetTextLength(u32 firsttag, ...)
{
  return(glw_GetTextLengthTL((tag *)&firsttag));
}
u32 glw_GetTextLengthTL(tag *taglist)
{
  u32 font;
  char *text;

  int ret=0;
  struct glw_Font *fnt;
  HFONT oldfont;
  SIZE size;

  debug_Begin();

  font=(u32 )tag_GetTagData(taglist,TAG_GLW_FONT,0L);
  text=(char *)tag_GetTagData(taglist,TAG_GLW_TEXT,0L);

  fnt=(struct glw_Font *)font;

  if(text!=NULL&&fnt!=NULL&&workDC!=NULL)
  {
    oldfont=SelectObject(workDC,fnt->handle);
    GetTextExtentPoint32(workDC,text,strlen(text),&size);
    SelectObject(workDC,oldfont);
    ret=size.cx;
  }

  debug_End();

  return((u32)ret);
}


// image handling
u32 glw_PutImage(u32 firsttag, ...)
{
  return(glw_PutImageTL((tag *)&firsttag));
}
u32 glw_PutImageTL(tag *taglist)
{
  u32 window;
  Vector_t *pixels;
  Rect_t *cliprect;
  int left;
  int top;
  int width;
  int height;

  struct glw_Window *win;
  struct glw_InternalBMI bmi;
  int ret,fr=0;
  u8 *buf=NULL;


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  pixels=(Vector_t *)tag_GetTagData(taglist,TAG_GLW_PIXELS,0L);
  cliprect=(Rect_t *)tag_GetTagData(taglist,TAG_GLW_CLIPRECT,0L);
  left=(int )tag_GetTagData(taglist,TAG_GLW_LEFT,0L);
  top=(int )tag_GetTagData(taglist,TAG_GLW_TOP,0L);
  width=(int )tag_GetTagData(taglist,TAG_GLW_WIDTH,0L);
  height=(int )tag_GetTagData(taglist,TAG_GLW_HEIGHT,0L);

  win=(struct glw_Window *)window;

  memset(&bmi,0,sizeof(struct glw_InternalBMI));

  bmi.bmiHeader.biSize=sizeof(BITMAPINFOHEADER);
  bmi.bmiHeader.biWidth=width;
  bmi.bmiHeader.biHeight=-height;
  bmi.bmiHeader.biPlanes=1;
  bmi.bmiHeader.biBitCount=32;
  bmi.bmiHeader.biXPelsPerMeter=1;
  bmi.bmiHeader.biYPelsPerMeter=1;
  if(wv>=3)  // NT4+
  {
    bmi.bmiHeader.biCompression=BI_BITFIELDS; //BI_RGB | BI_BITFIELDS (RGB: BGR_)
    bmi.bmiColors[0].rgbGreen=0xff;
    bmi.bmiColors[1].rgbRed=0xff;
    bmi.bmiColors[2].rgbReserved=0xff;
    buf=pixels->data;
  }
  else
  {
    int mx,j;
    u32 px;
    u8 *pxb;
    u32 *npx;

    bmi.bmiHeader.biCompression=BI_RGB; //BI_RGB | BI_BITFIELDS (RGB: BGR_)
    if(NULL!=(buf=mem_malloc(width*height*4)))
    {
      fr=1;
      mx=width*height;
      for(j=0,pxb=pixels->data,npx=(u32 *)buf;j<mx;j++,pxb+=4)
      {
        px=pxb[0]<<24|pxb[1]<<16|pxb[2]<<8|pxb[3];
        *npx++=px;
      }
    } else buf=pixels->data;
  }
  ret=-!SetDIBitsToDevice(win->hdcMem,left,top,cliprect->width,cliprect->height,0,0,0,height,buf,(BITMAPINFO *)&bmi,DIB_RGB_COLORS);


  if(fr!=0) mem_free(buf);

  debug_End();

  return((u32)0);
};


// screen info
u32 glw_GetScreenDimensions(u32 firsttag, ...)
{
  return(glw_GetScreenDimensionsTL((tag *)&firsttag));
}
u32 glw_GetScreenDimensionsTL(tag *taglist)
{
  u32 window;
  Rect_t *rect;


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_GLW_RECT,0L);

  rect->left=0;
  rect->top=0;
  rect->width=buffsizeX;
  rect->height=buffsizeY;

  debug_End();

  return((u32)0);
}


u32 glw_Sleep(u32 firsttag, ...)
{
  return(glw_SleepTL((tag *)&firsttag));
}
u32 glw_SleepTL(tag *taglist)
{
  u32 millisec;

  debug_Begin();

  millisec=(u32 )tag_GetTagData(taglist,TAG_GLW_MILLISEC,0L);

  Sleep((DWORD)millisec);

  debug_End();

  return(0L);
}


u32 glw_TimerStart(u32 firsttag, ...)
{
  return(glw_TimerStartTL((tag *)&firsttag));
}
u32 glw_TimerStartTL(tag *taglist)
{
  u32 window;
  u32 millisec;
  u32 userdata;

  struct glw_Window *win;
  u32 id;

  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  millisec=(u32 )tag_GetTagData(taglist,TAG_GLW_MILLISEC,0L);
  userdata=(u32 )tag_GetTagData(taglist,TAG_GLW_USERDATA,0L);

  win=(struct glw_Window *)window;

  id=SetTimer(win->window,userdata,(UINT)millisec,NULL);

  debug_End();

  return((u32)id);
}


u32 glw_TimerCancel(u32 firsttag, ...)
{
  return(glw_TimerCancelTL((tag *)&firsttag));
}
u32 glw_TimerCancelTL(tag *taglist)
{
  u32 window;
  u32 id;

  struct glw_Window *win;

  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  id=(u32 )tag_GetTagData(taglist,TAG_GLW_ID,0L);

  win=(struct glw_Window *)window;

  KillTimer(win->window,id);

  debug_End();
  return(0L);
}


u32 glw_GetTime(u32 firsttag, ...)
{
  return(glw_GetTimeTL((tag *)&firsttag));
}
u32 glw_GetTimeTL(tag *taglist)
{
  struct glw_Time *tm;

  SYSTEMTIME st;
  u32 ret=0L;


  debug_Begin();

  tm=(struct glw_Time *)tag_GetTagData(taglist,TAG_GLW_TM,0L);

  ret=(u32)time(NULL);
  if(tm!=NULL)
  {
    GetSystemTime(&st);
    tm->secs=ret;
    tm->millis=(u32)st.wMilliseconds;
  }

  debug_End();

  return((u32)ret);
}



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

  debug_Begin();

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

  debug_End();

  return(ret);
}


static char *glw_ConvPath(char *name)
{
  char *name2=NULL;
  int i,j;

  debug_Begin();

  if(NULL!=(name2=mem_malloc(strlen(name)*2+2)))
  {
    for(i=j=0;name[i]!='\0';i++)
    {
      if(name[i]!='/') name2[j++]=name[i];
      else name2[j++]='\\';
    }
    name2[j]='\0';
  }

  debug_End();

  return(name2);
}


u32 glw_OpenModule(char *name)
{
    u32 ret=0L;
  HMODULE hmod;
  int (*module_Init)(u32,bases_Modules_t *);
  char *name2;

    debug_Begin();

  if(NULL!=(name2=glw_ConvPath(name)))
  {
    debug_Message("Module request: '%s' -> '%s'",name,name2);
      hmod=LoadLibraryEx(name2,NULL,0L);
      if(hmod!=NULL)
      {
        module_Init=(int (*)(u32,bases_Modules_t *))GetProcAddress(hmod,"module_Init");
        ret=(u32)hmod;
        module_Init(ret,&bases_modules);
      }
      else debug_Warning("Cannot load module '%s'!",name);
      mem_free(name2);
  }
  if(ret==0L) debug_Error("cannot load module '%s'",name);

    debug_End();

    return(ret);
}
void glw_CloseModule(u32 handle)
{
    if(handle!=0L)
    {
        FreeLibrary((HMODULE)handle);
    }
}


//dir handling

// open a directory ret=0L bad path
glw_Dir_t *glw_DirOpen(char *path)
{
  glw_Dir_t *dir=NULL;
  char *path2;
  char *path3;
  WIN32_FIND_DATA FindFileData;

  debug_Begin();

  FindFileData.cFileName[0]='\0';
  if(NULL!=(path2=glw_ConvPath(path)))
  {
    if(NULL!=(path3=mem_malloc(strlen(path2)+3)))
    {
      strcpy(path3,path2);
      strcat(path3,"\\*");
      if(NULL!=(dir=mem_malloc(sizeof(struct glw_Dir))))
      {
        dir->filename=NULL;
        if(INVALID_HANDLE_VALUE!=(dir->hdir=FindFirstFile(path3,&FindFileData)))
        {
          dir->filename=common_strdup(FindFileData.cFileName);
        }
      }
      mem_free(path3);
    }
    mem_free(path2);
  }

  debug_End();

  return(dir);
}
// free this dir handle
void glw_DirClose(glw_Dir_t *dir)
{
  debug_Begin();

  if(dir!=NULL)
  {
    if(dir->filename!=NULL) mem_free(dir->filename);
    if(dir->hdir!=INVALID_HANDLE_VALUE) FindClose(dir->hdir);
    mem_free(dir);
  }

  debug_End();
}
// get next file from dir (NULL -> end)
char *glw_DirNext(glw_Dir_t *dir)
{
  char *ret=NULL;
  WIN32_FIND_DATA FindFileData;

  debug_Begin();

  FindFileData.cFileName[0]='\0';
  if(dir!=NULL)
  {
    if(dir->filename!=NULL)
    {
      ret=dir->filename;
      dir->filename=NULL;
    }
    else
    {
      FindNextFile(dir->hdir,&FindFileData);
      if(FindFileData.cFileName[0]!='\0') ret=common_strdup(FindFileData.cFileName);
      else ret=NULL;
    }
  }

  debug_End();

  return(ret);
}


/*
 *  window shape: bitmap 1-opaque 0-transparent (+padding)
 */
u32 glw_SetWindowShape(u32 firsttag, ...)
{
  return(glw_SetWindowShapeTL((tag *)&firsttag));
}
u32 glw_SetWindowShapeTL(tag *taglist)
{
  struct glw_Window *win;
  Vector_t *vector;
  int width;
  int height;
  int bytewidth;

  u32 ret=~0L;
  int x,y,addr,bit;
  HRGN hRgn;
  HRGN hTmpRgn;
  int state;
  int prevx=-1;

  debug_Begin();

  win=(struct glw_Window *)tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  vector=(Vector_t *)tag_GetTagData(taglist,TAG_GLW_VECTOR,0L);
  width=(int)tag_GetTagData(taglist,TAG_GLW_WIDTH,0L);
  height=(int)tag_GetTagData(taglist,TAG_GLW_HEIGHT,0L);
  bytewidth=(int)tag_GetTagData(taglist,TAG_GLW_BYTEWIDTH,0L);

  if(win!=NULL)
  {
    ret=0L;
    state=win->user_state;
    win->user_state=GLWWS_SKINNING;
    if(vector!=NULL&&vector->data!=NULL&&vector->size>0&&width>0&&height>0&&bytewidth>0)
    {
      if(vector->size==height*bytewidth)
      {
        if((hRgn=CreateRectRgn(0,0,width,height)))
        {
          //scan bitmap
          for(y=0;y<height;y++)
          {
            for(x=0;x<width;x++)
            {
              addr=y*bytewidth+(x/8);
              bit=1<<(7-(x%8));
              if(((vector->data[addr]&bit)&0xff)==0)
              {
                if(prevx<0) prevx=x;
              }
              else if(prevx>=0)
              {
                if((hTmpRgn=CreateRectRgn(prevx,y,x,y+1)))
                {
                  CombineRgn(hRgn,hRgn,hTmpRgn,RGN_XOR);
                  DeleteObject(hTmpRgn);
                }
                prevx=-1;
              }
            }
            if(prevx>=0)
            {
              if((hTmpRgn=CreateRectRgn(prevx,y,x,y+1)))
              {
                CombineRgn(hRgn,hRgn,hTmpRgn,RGN_XOR);
                DeleteObject(hTmpRgn);
              }
              prevx=-1;
            }
          }
          // apply region
          SetWindowRgn(win->window,hRgn,FALSE);
        }
      }
      else debug_Error("Vector size doesn't match");
    }
    else
    {
      //insert simple, rectangular shape
      SetWindowRgn(win->window,NULL,FALSE);
    }
    win->user_state=state;
  }

  debug_End();

  return(ret);
}


int glw_GetTerminalByteOrder(u32 connection)
{
  struct glw_Connection *conn=(struct glw_Connection *)connection;
  int ret=-1;

  debug_Begin();

  if(conn!=NULL) ret=conn->termbyteorder;

  debug_End();

  return(ret);
}


int glw_ReadTerm(u32 connection, u8 *buff, int len)
{
  int ret=-1;
  struct glw_Connection *conn=(struct glw_Connection *)connection;
  int r;

  debug_Begin();

  if(conn!=NULL)
  {
    ret=0;
    if((r=recv(conn->sterm,buff,len,MSG_WAITALL))!=len)
    {
      ret=-1;
      debug_Error("Socket error: (r=%d) %d",r,WSAGetLastError());
      conn->cuser.quit=1;
    }
  }

  debug_End();

  return(ret);
}


int glw_SendTerm(u32 connection, u8 *buff, int len)
{
  int ret=-1;
  struct glw_Connection *conn=(struct glw_Connection *)connection;

  debug_Begin();

  if(conn!=NULL&&buff!=NULL&&len>0)
  {
    ret=send(conn->sterm,buff,len,0);
  }

  debug_End();

  return(ret);
}


//END//

---