oexINT CImage::Encode( oexPBYTE *x_buf, oexINT *x_pnSize, oexCSTR x_pType )
{_STT();

#if !defined( OEX_ENABLE_XIMAGE )
	return 0;
#else

	// Lose old memory
	ReleaseEncodeMemory();

	// Get image object
	if ( !oexCHECK_PTR( m_pimg ) )
		return 0;
	CCxCustomImg *pimg = (CCxCustomImg*)m_pimg;

	// Copy filename
	if ( oexCHECK_PTR( x_pType ) )
		m_filename = x_pType;

	// Get the file type
	DWORD type = ( oexCHECK_PTR( x_pType ) && *x_pType ) ? GetFileType( x_pType ) : -1;
	if ( (DWORD)-1 == type )
		return 0;

	// Encode the image
	BYTE *pMem = 0;
	long lSize = 0;
	if ( !pimg->Encode( pMem, lSize, type ) || !oexCHECK_PTR( pMem ) || 0 >= lSize )
		return 0;

	// Save pointers
	m_pMem = pMem;
	m_uMemSize = (oexUINT)lSize;

	// +++ This would be nice, it would save a copy, but to make it work
	//     we must ensure that xImage uses oex_malloc() to allocate
	//     the memory.
//	m_mem.setBuffer( (CBin::t_byte*)pMem, lSize );

	// Save data
	if ( oexCHECK_PTR( x_buf ) )
		 *x_buf = (oexPBYTE)m_pMem;
	if ( oexCHECK_PTR( x_pnSize ) )
		*x_pnSize = m_uMemSize;

	return lSize;

#endif
}

/*
 * Check whether a given standard handle needs to be redirected.
 *
 * If you run a Windows-subsystem program from cmd.exe on Windows XP,
 * and you haven't redirected the handle in question, GetStdHandle()
 * succeeds (so it doesn't return INVALID_HANDLE_VALUE or NULL), but
 * GetFile_type fails on the results with ERROR_INVALID_HANDLE.
 * In that case, redirection to a console is necessary.
 *
 * If you run it from the shell prompt in "mintty" in at least some
 * versions of Cygwin on Windows XP, and you haven't redirected the
 * handle in question, GetStdHandle() succeeds and returns a handle
 * that's a pipe or socket; it appears mintty reads from it and outputs
 * what it reads to the console.
 */
static gboolean
needs_redirection(int std_handle)
{
    HANDLE fd;
    DWORD handle_type;
    DWORD error;

    fd = GetStdHandle(std_handle);
    if (fd == NULL) {
        /*
         * No standard handle.  According to Microsoft's
         * documentation for GetStdHandle(), one reason for
         * this would be that the process is "a service on
         * an interactive desktop"; I'm not sure whether
         * such a process should be popping up a console.
         *
         * However, it also appears to be the case for
         * the standard input and standard error, but
         * *not* the standard output, for something run
         * with a double-click in Windows Explorer,
         * sow we'll say it needs redirection.
         */
        return TRUE;
    }
    if (fd == INVALID_HANDLE_VALUE) {
        /*
         * OK, I'm not when this would happen; return
         * "no redirection" for now.
         */
        return FALSE;
    }
    handle_type = GetFileType(fd);
    if (handle_type == FILE_TYPE_UNKNOWN) {
        error = GetLastError();
        if (error == ERROR_INVALID_HANDLE) {
            /*
             * OK, this appears to be the case where we're
             * running something in a mode that needs a
             * console.
             */
            return TRUE;
        }
    }

    /*
     * Assume no redirection is needed for all other cases.
     */
    return FALSE;
}

/**
 * Read header from the input file.
 * @param [in] InputFile - Input file to read from
 */
void THDF5_FileHeader::ReadHeaderFromInputFile(THDF5_File & InputFile){
    
    // read file type
    HDF5_FileHeaderValues[hdf5_fhi_file_type] = InputFile.ReadStringAttribute("/",HDF5_FileHeaderNames[hdf5_fhi_file_type].c_str());
    
    if (GetFileType() == hdf5_ft_input) {                
        HDF5_FileHeaderValues[hdf5_fhi_created_by]       = InputFile.ReadStringAttribute("/",HDF5_FileHeaderNames[hdf5_fhi_created_by].c_str());
        HDF5_FileHeaderValues[hdf5_fhi_creation_date]    = InputFile.ReadStringAttribute("/",HDF5_FileHeaderNames[hdf5_fhi_creation_date].c_str());
        HDF5_FileHeaderValues[hdf5_fhi_file_description] = InputFile.ReadStringAttribute("/",HDF5_FileHeaderNames[hdf5_fhi_file_description].c_str());
        HDF5_FileHeaderValues[hdf5_fhi_major_version]    = InputFile.ReadStringAttribute("/",HDF5_FileHeaderNames[hdf5_fhi_major_version].c_str());
        HDF5_FileHeaderValues[hdf5_fhi_minor_version]    = InputFile.ReadStringAttribute("/",HDF5_FileHeaderNames[hdf5_fhi_minor_version].c_str());        
    }
    
    
}// end of ReadHeaderFromInputFile

void init_stdio(void) {

    int i;
    __gOpenFiles[0].handle = GetStdHandle(STD_INPUT_HANDLE);
    __gOpenFiles[1].handle = GetStdHandle(STD_OUTPUT_HANDLE);
    __gOpenFiles[2].handle = GetStdHandle(STD_ERROR_HANDLE);

    __gOpenFiles[0].flags = (GetFileType(ULongToPtr(STD_INPUT_HANDLE))==
                             FILE_TYPE_CHAR)?  FCONSOLE:0;
    __gOpenFiles[1].flags = (GetFileType(ULongToPtr(STD_OUTPUT_HANDLE))==
                             FILE_TYPE_CHAR)?  FCONSOLE:0;
    __gOpenFiles[2].flags = (GetFileType(ULongToPtr(STD_ERROR_HANDLE))==
                             FILE_TYPE_CHAR)?  FCONSOLE:0;

    for(i=3; i<__MAX_OPEN_FILES; i++) {
        __gOpenFiles[i].handle = INVHL;
        __gOpenFilesCopy[i].handle = INVHL;
        __gOpenFiles[i].flags = 0;
    }

    my_stdin = &__gOpenFiles[0];
    my_stdout = &__gOpenFiles[1];
    my_stderr = &__gOpenFiles[2];
}

//===================>>> vedTextEditor::TextMouseDown <<<====================
  void vedTextEditor::TextMouseDown(int row, int col, int button)
  {
    static int clicks = 0;
    int btn = (GetFileType() == gccError || GetFileType() == bccError)
	 ? 1 : button;

    long oldLine = GetCurLine();		// remember current position
    int oldCol = getColPos();
    
    vTextEditor::TextMouseDown(row, col, btn);	// translate to left

    if (button == 1 && oldLine == GetCurLine() && oldCol == getColPos()) // double click...
      {
	++clicks;
	if (clicks > 3)
	    clicks = 1;
	setSelection(clicks);
      }
    else
      {
	clicks = 0;
      }

  }

static void
lseek_work_cb(uv_work_t *req)
{
  struct req * r = req->data;
  const int fd = (int)r->buf.len;
  int64_t offset = voids_to_int64_t(&r->c);
#ifdef _WIN32
  const DWORD whence = r->offset;
  HANDLE handle = (HANDLE)(0 + _get_osfhandle(fd));
  if ( handle == INVALID_HANDLE_VALUE ){
    r->offset = UV_EBADF;
    offset = -1;
  }
  else if ( GetFileType(handle) != FILE_TYPE_DISK ){
    /*
      from: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365542(v=vs.85).aspx

      "You cannot use the SetFilePointerEx function with a handle to a
      nonseeking device such as a pipe or a communications device. To
      determine the file type for hFile, use the GetFileType function."

      But it doesn't return an error for whatever reason. So I check
      it manually
    */
    r->offset = UV_ESPIPE;
    offset = -1;
  }
  else {
    LARGE_INTEGER distance_to_move;
    LARGE_INTEGER new_position;
    distance_to_move.QuadPart = offset;
    if ( SetFilePointerEx(handle,distance_to_move,&new_position,whence) ){
      offset = new_position.QuadPart;
    }
    else {
      DWORD er =  GetLastError();
      r->offset = uwt_translate_sys_error(er);
      offset = -1;
    }
  }
#else
  const int whence = r->offset;
  errno = 0;
  offset = lseek(fd,offset,whence);
  r->offset = -errno;
#endif
  int64_t_to_voids(offset,&r->c);
}

int rktio_system_fd_is_terminal(rktio_t *rktio, intptr_t fd)
{
#ifdef RKTIO_SYSTEM_UNIX
  return isatty(fd);
#endif
#ifdef RKTIO_SYSTEM_WINDOWS
  if (GetFileType((HANDLE)fd) == FILE_TYPE_CHAR) {
    DWORD mode;
    if (GetConsoleMode((HANDLE)fd, &mode))
      return 1;
    else
      return 0;
  } else
    return 0;
#endif
}

void print_utf8_string(const char *string)
{
#ifdef G_OS_WIN32
    HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
    if (GetFileType(h) != FILE_TYPE_CHAR)
        fputs(string, stdout);
    else {
        gunichar2 *utf16 = g_utf8_to_utf16(string, -1, NULL, NULL, NULL);
        fflush(stdout);
        WriteConsoleW(h, utf16, wcslen(utf16), NULL, NULL);
        g_free(utf16);
    }
#else
    g_print("%s", string);
#endif
}

/*
    \internal
*/
bool QFSFileEnginePrivate::nativeIsSequential() const
{
#if !defined(Q_OS_WINCE) && !defined(Q_OS_WINRT)
    HANDLE handle = fileHandle;
    if (fh || fd != -1)
        handle = (HANDLE)_get_osfhandle(fh ? QT_FILENO(fh) : fd);
    if (handle == INVALID_HANDLE_VALUE)
        return false;

    DWORD fileType = GetFileType(handle);
    return (fileType == FILE_TYPE_CHAR)
            || (fileType == FILE_TYPE_PIPE);
#else
    return false;
#endif
}

char *
getpass (const char * prompt)
{
  static char input[256];
  HANDLE in;
  HANDLE err;
  DWORD  count;

  in = GetStdHandle (STD_INPUT_HANDLE);
  err = GetStdHandle (STD_ERROR_HANDLE);

  if (in == INVALID_HANDLE_VALUE || err == INVALID_HANDLE_VALUE)
    return NULL;

  if (WriteFile (err, prompt, strlen (prompt), &count, NULL))
    {
      int istty = (GetFileType (in) == FILE_TYPE_CHAR);
      DWORD old_flags;
      int rc;

      if (istty)
	{
	  if (GetConsoleMode (in, &old_flags))
	    SetConsoleMode (in, ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT);
	  else
	    istty = 0;
	}
      rc = ReadFile (in, input, sizeof (input), &count, NULL);
      if (count >= 2 && input[count - 2] == '\r')
	input[count - 2] = '\0';
      else
	{
	  char buf[256];
	  while (ReadFile (in, buf, sizeof (buf), &count, NULL) > 0)
	    if (count >= 2 && buf[count - 2] == '\r')
	      break;
	}
      WriteFile (err, "\r\n", 2, &count, NULL);
      if (istty)
	SetConsoleMode (in, old_flags);
      if (rc)
	return input;
    }

  return NULL;
}

static value do_fstat(value handle, int use_64)
{
  int ret;
  struct _stat64 buf;
  __int64 st_ino;
  HANDLE h;
  DWORD ft;

  st_ino = 0;
  memset(&buf, 0, sizeof buf);
  buf.st_nlink = 1;

  h = Handle_val(handle);
  ft = GetFileType(h) & ~FILE_TYPE_REMOTE;
  switch(ft) {
  case FILE_TYPE_DISK:
    if (!safe_do_stat(0, use_64, NULL, Handle_val(handle), &st_ino, &buf)) {
      uerror("fstat", Nothing);
    }
    break;
  case FILE_TYPE_CHAR:
    buf.st_mode = S_IFCHR;
    break;
  case FILE_TYPE_PIPE:
    {
      DWORD n_avail;
      if (Descr_kind_val(handle) == KIND_SOCKET) {
        buf.st_mode = S_IFSOCK;
      }
      else {
        buf.st_mode = S_IFIFO;
      }
      if (PeekNamedPipe(h, NULL, 0, NULL, &n_avail, NULL)) {
        buf.st_size = n_avail;
      }
    }
    break;
  case FILE_TYPE_UNKNOWN:
    unix_error(EBADF, "fstat", Nothing);
  default:
    win32_maperr(GetLastError());
    uerror("fstat", Nothing);
  }
  return stat_aux(use_64, st_ino, &buf);
}

	config_struct* getConfigObject(LPCWSTR name,config_struct* obj = 0){
		static ObjectList<config_struct>* dbList = 0;
		LocalCriticalSection lcs(_configCs);
		if(dbList==0){
			dbList = new (mallocGlobalStaticMem(sizeof(ObjectList<config_struct>))) ObjectList<config_struct>;
		}

		if(obj!=NULL){
			obj->icount--;
			if(obj->icount==0){
				dbList->Delete(obj);
			}
			return 0;
		}
		String fn,title;
		if(WcsLength(name)==0){
			fn = App::GetAppDirectory();
			title = App::GetAppName();
			FPLinkPath(fn,title);
			FPLinkExt(fn,L"json");
		}else{
			fn = name;
		}

		config_struct* rs = 0;
		for(uint i=0;i<dbList->Count();i++){
			rs = &(*dbList)[i];
			if(FPIsSame(fn,rs->FileName)){
				rs->icount++;
				return rs;
			}
		}
		rs = new config_struct;
		rs->icount = 1;
		if(1!=GetFileType(fn)){
			File f;
			f.Create(fn);
		}
		if(!rs->Tree.LoadFromFile(fn)){
			CONASSERT(L"config file is not a valid json format");
		}
		rs->FileName = fn;
		dbList->AddIn(rs);
		return rs;
	}

void
brhist_jump_back(void)
{
#if defined(_WIN32)  &&  !defined(__CYGWIN__)
    if (GetFileType(Console_IO.Console_Handle) != FILE_TYPE_PIPE) {
        COORD   Pos;
        CONSOLE_SCREEN_BUFFER_INFO CSBI;

        GetConsoleScreenBufferInfo(Console_IO.Console_Handle, &CSBI);
        Pos.Y = CSBI.dwCursorPosition.Y - brhist.hist_printed_lines;
        Pos.X = 0;
        SetConsoleCursorPosition(Console_IO.Console_Handle, Pos);
    }
#else
    while (brhist.hist_printed_lines-- > 0)
        fputs(Console_IO.str_up, Console_IO.Console_fp);
#endif
}

/*	move up cursor */
void cursor_up(int rows)
{
	HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);

	if (GetFileType(hStdOut) == FILE_TYPE_CHAR) {
		CONSOLE_SCREEN_BUFFER_INFO console_info;

		if (GetConsoleScreenBufferInfo(hStdOut, &console_info)) {

			console_info.dwCursorPosition.X = 0;
			console_info.dwCursorPosition.Y =
				(short)(console_info.dwCursorPosition.Y - rows);

			SetConsoleCursorPosition(
				hStdOut, console_info.dwCursorPosition);
		}
	}
}

/**
	读入文件
	@param filename 被读入的文件名
*/
bool Open(char *filename) {
    int nSrcLen = strlen(filename);
    if ( MAX_PATH <= nSrcLen)
        strcpy_s(g_FileName, nSrcLen, filename);
    else
        return false;//输入过长

	Clear();//先清理了

    g_DataLen = GetFileLength(g_FileName);
    //有内容存在
    if( g_DataLen > 0 )	{
        g_pData = _MALLOC(char,g_DataLen + 1);//多个"\0"
        FILE *fp = fopen(g_FileName, "rb");
        fread(g_pData, g_DataLen, 1, fp);		//读数据
        fclose(fp);
		g_FileType= GetFileType();//判断文件类型是dos还是unix
    } else {

/*	erase to the end of current line */
void erase_eol()
{
	HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);

	if (GetFileType(hStdOut) == FILE_TYPE_CHAR) {
		CONSOLE_SCREEN_BUFFER_INFO console_info;

		if (GetConsoleScreenBufferInfo(hStdOut, &console_info)) {
			DWORD result;

			FillConsoleOutputCharacter(
				hStdOut, ' ',
				console_info.dwSize.X - console_info.dwCursorPosition.X,
				console_info.dwCursorPosition,
				&result);
		}
	}
}

static int is_console(int fd)
{
	CONSOLE_SCREEN_BUFFER_INFO sbi;
	DWORD mode;
	HANDLE hcon;

	static int initialized = 0;

	/* get OS handle of the file descriptor */
	hcon = (HANDLE) _get_osfhandle(fd);
	if (hcon == INVALID_HANDLE_VALUE)
		return 0;

	/* check if its a device (i.e. console, printer, serial port) */
	if (GetFileType(hcon) != FILE_TYPE_CHAR)
		return 0;

	/* check if its a handle to a console output screen buffer */
	if (!fd) {
		if (!GetConsoleMode(hcon, &mode))
			return 0;
		/*
		 * This code path is only reached if there is no console
		 * attached to stdout/stderr, i.e. we will not need to output
		 * any text to any console, therefore we might just as well
		 * use black as foreground color.
		 */
		sbi.wAttributes = 0;
	} else if (!GetConsoleScreenBufferInfo(hcon, &sbi))
		return 0;

	if (fd >= 0 && fd <= 2)
		fd_is_interactive[fd] |= FD_CONSOLE;

	/* initialize attributes */
	if (!initialized) {
		console = hcon;
		attr = plain_attr = sbi.wAttributes;
		negative = 0;
		initialized = 1;
	}

	return 1;
}

int _tmain(int argc, _TCHAR* argv[])
{
	DWORD aid = 0;
	video_info_t VideoInfo;
	audio_info_t AudioInfo;
	HMODULE hDLL;
	if (argc < 2)
		return 0;
	if (argc > 2)
		aid = _wtoi(argv[2]);
	if (NULL == (hDLL = LoadLibraryA("dshownative.dll")))
		return 0;
	InitDShowGraphFromFile = (TInitDShowGraphFromFile)GetProcAddress(hDLL,"InitDShowGraphFromFileW");
	StartGraph = (TGraphOperate)GetProcAddress(hDLL,"StartGraph");
	StopGraph = (TGraphOperate)GetProcAddress(hDLL,"StopGraph");
	DestroyGraph = (TGraphOperate)GetProcAddress(hDLL,"DestroyGraph");
	if (!(g_pdgi = InitDShowGraphFromFile(argv[1],MEDIASUBTYPE_YV12,0,0,VCallBackProc,CallBackProc,&VideoInfo,&AudioInfo)))
		return 0;
#ifndef _DEBUG
	waveheader.channels = AudioInfo.nChannels;
	waveheader.sample_rate = AudioInfo.nSamplesPerSec;
	waveheader.bits_per_sample = AudioInfo.wBitsPerSample;
	waveheader.block_align = waveheader.channels * waveheader.bits_per_sample / 8;
	waveheader.avg_bytes_sec = waveheader.block_align * waveheader.sample_rate;
	waveheader.format_tag = 0x3;
	StdOut = GetStdHandle(STD_OUTPUT_HANDLE);
	WriteFile(StdOut,&waveheader,sizeof(TWaveHeader),&dwWritten,NULL);
#endif
	SetConsoleCtrlHandler(HandlerRoutine, TRUE);
	hEvent = CreateEventA(NULL,FALSE,FALSE,NULL);
	StartGraph(g_pdgi);
	WaitForSingleObject(hEvent,INFINITE);
	StopGraph(g_pdgi);DestroyGraph(g_pdgi);
	if (GetFileType(StdOut) == FILE_TYPE_DISK) {
		waveheader.data_size = GetFileSize(StdOut,NULL) - sizeof(TWaveHeader);
		waveheader.size = waveheader.data_size + sizeof(TWaveHeader) - 8;
		SetFilePointer(StdOut,0,NULL,FILE_BEGIN);
		WriteFile(StdOut,&waveheader,sizeof(TWaveHeader),&dwWritten,NULL);
	}
	CloseHandle(StdOut);
	CoUninitialize();
	return 1;
}

oexINT CImage::Encode( oexPBYTE x_pBuf, oexINT x_nSize, oexCSTR x_pType )
{_STT();

#if !defined( OEX_ENABLE_XIMAGE )
	return 0;
#else

	// Sanity checks
	if ( oexCHECK_PTR( x_pBuf ) || !x_nSize )
		return 0;

	// Get image object
	if ( !oexCHECK_PTR( m_pimg ) )
		return 0;
	CCxCustomImg *pimg = (CCxCustomImg*)m_pimg;

	// Use filename if not supplied
	if ( !oexCHECK_PTR( x_pType ) )
		x_pType = m_filename.Ptr();

	// Get the file type
	DWORD type = GetFileType( x_pType );
	if ( (DWORD)-1 == type )
		return 0;

	// Wrap the memory pointer
	s_CxMemFile mf( x_pBuf, x_nSize );

	// Encode the image
	if ( !pimg->Encode( &mf, type ) )
	{	mf.Detach(); return 0; }

	// Get the number of bytes encoded
	oexINT nEncoded = mf.Size();

	// Detach from the buffer
	mf.Detach();

	return nEncoded;

#endif
}

void exit(int status)
#endif
{

		if (!__aborting)
	{
		__begin_critical_region(atexit_funcs_access);
		
		while (atexit_curr_func > 0)
			(*atexit_funcs[--atexit_curr_func])();
		
#if (__dest_os == __win32_os) && (STOP_PROGRAM_BEFORE_EXIT==1)

	if(GetFileType(GetStdHandle(STD_OUTPUT_HANDLE))==FILE_TYPE_CHAR)
{
	//printf("\n \n Press Enter to continue \n");
	//fflush(stdin);
	//getc(stdin);
}
#endif

		__end_critical_region(atexit_funcs_access);

	 /*
	 970218 bkoz
	 		need to move destroy global chain above __stdio_exit as
		 	some static objects may have destructors that flush streams
	 */
	 #if !__INTEL__
	 #if  __POWERPC__ || __CFM68K__ || (__MC68K__ && __A5__) || (__dest_os == __be_os)
		__destroy_global_chain();
	 #endif
	 #endif
		if (__stdio_exit)
		{
			(*__stdio_exit)();
			__stdio_exit = 0;
		}
	}

	__exit(status);
}