glw_w32.c

Unique net-enabled GUI system based state of the art coding solutions with strong XML support.

  {
    // 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->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->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);
}


/**
 * \param TAG_GLW_FONT                      u32
 */
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
/**
 * \param TAG_GLW_WINDOW                    u32
 * \param TAG_GLW_FONT                      u32
 * \param TAG_GLW_CLIPRECT                  Rect_t *
 * \param TAG_GLW_TEXT                      char *
 * \param TAG_GLW_FLAGS                     u32
 */
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;
///  HBITMAP hbmOld;
  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;
///    hbmOld=SelectObject(win->hdcMem,win->hbmMem);
    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);
///    SelectObject(win->hdcMem,hbmOld);
  }

  debug_End();

  return((u32)0);
};


/**
 * \param TAG_GLW_FONT                      u32
 */
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);
}


/**
 * \param TAG_GLW_FONT                      u32
 * \param TAG_GLW_TEXT                      char *
 */
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
/**
 * \param TAG_GLW_WINDOW                    u32
 * \param TAG_GLW_PIXELS                    u8 *
 * \param TAG_GLW_CLIPRECT                  Rect_t *
 * \param TAG_GLW_LEFT                      int
 * \param TAG_GLW_TOP                       int
 * \param TAG_GLW_WIDTH                     int
 * \param TAG_GLW_HEIGHT                    int
 */
u32 glw_PutImage(u32 firsttag, ...)
{
  return(glw_PutImageTL((tag *)&firsttag));
}
u32 glw_PutImageTL(tag *taglist)
{
  u32 window;
  u8 *pixels;
  Rect_t *cliprect;
  int left;
  int top;
  int width;
  int height;

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


  debug_Begin();

  window=(u32 )tag_GetTagData(taglist,TAG_GLW_WINDOW,0L);
  pixels=(u8 *)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));

///  hbmOld=SelectObject(win->hdcMem,win->hbmMem);
  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;
  }
  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,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;
  }
  ret=-!SetDIBitsToDevice(win->hdcMem,left,top,cliprect->width,cliprect->height,0,0,0,height,buf,(BITMAPINFO *)&bmi,DIB_RGB_COLORS);

///  SelectObject(win->hdcMem,hbmOld);

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

  debug_End();

  return((u32)0);
};


// screen info
/**
 * \param TAG_GLW_WINDOW                    u32
 * \param TAG_GLW_RECT                      Rect_t *
 */
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);
}


/**
 * \param TAG_GLW_WINDOW                    u32
 * \param TAG_GLW_MILLISEC                  u32
 * \param TAG_GLW_USERDATA                  u32
 */
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);
}


/**
 * \param TAG_GLW_WINDOW                    u32
 * \param TAG_GLW_ID                        u32
 */
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);
}


/**
 * \param TAG_GLW_TM                        struct glw_Time *
 */
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();

  debug_Message("function ID : %d",function-GLW_FUNCBASE);

  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);
}


/*
      HMODULE hmod;
      MYPROC fproc;
      MYINIT finit;

      hmod=LoadLibraryEx("tst.Gadget_t",NULL,0L);
      if(hmod!=NULL)
      {
        finit=(MYINIT)GetProcAddress(hmod,"tstinit");
        fproc=(MYPROC)GetProcAddress(hmod,"tstfunc");
        if(fproc!=NULL&&finit!=NULL)
        {
          printf("internal init: 10->%d\n",(finit)(10));
          (fproc)();
        }
        FreeLibrary(hmod);
      }
*/
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'\n",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);
	  }
	  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);
}

//END//