#define XVT_INCL_NATIVE
#define XI_INTERNAL
#include <xinclude.h>
#include <os_dep.h>    

#include <commdlg.h>
#include <toolhelp.h>  
#include <spool.h>

#ifndef ATTR_WIN_USE_CTL3D
#include <ctl3d.h>
#endif

#include <ctype.h>
#include <dos.h>

#include <applicat.h>
#include <colors.h>
#include <mask.h>

extern "C" { WINDOW xvtwi_hwnd_to_window(HWND); }

// By Matt Pietrek                           
//########################################################################
// Code that does the real work
//########################################################################                          

#pragma hdrstop
#include "prochook.h"

//
// Central function that modifies a module table to trick the loader
// into letting a second instance of a multiple data segment program run.
//
HIDDEN int MungeModuleHeader( HINSTANCE hInstance, BOOL fMunge )
{ 
    HMODULE hModuleSel;
    LPSTR lpszModName, lpszFileName;
    BYTE cbModuleName;
    static BOOL fResidentNamesMunged = FALSE;
    
    hModuleSel = SELECTOROF(    // Convert the HINSTANCE to an HMODULE
        GlobalLock(GetModuleHandle((LPSTR)MAKELP(0,hInstance))));

    if ( hModuleSel == 0 )      // Make sure we succeeded.
        return 0;

    //
    // First, we'll take care of the resident names table
    //
    if ( FALSE == fResidentNamesMunged )
    {
        // Make pointers to the module name in the resident names table
        lpszModName = (LPSTR)MAKELP(hModuleSel,
                                    *(WORD FAR *)MAKELP(hModuleSel, 0x26) );

        // Get the module name length, and advance to the actual string
        cbModuleName = *lpszModName++;   // First byte is a length byte
        
        // Convert the first uppercase letter of the modulename to lowercase
        while ( cbModuleName )
        {
            if ( isupper(*lpszModName) )
            {
                *lpszModName = tolower(*lpszModName); break;
            }
            cbModuleName--; lpszModName++;
        }
        
        if ( cbModuleName == 0 )    // Make sure we succeeded
            return 0;

        // Remember that we've done this, so that we don't bother doing
        // it in the future.
        fResidentNamesMunged = TRUE;
    }

    //
    // Now, we'll turn our attention to the module file name in the OFSTRUCT
    //
    lpszFileName = (LPSTR)MAKELP(hModuleSel,
                                 *(WORD FAR *)MAKELP(hModuleSel, 0x0A));

    // Position to the end of the filename. First byte is a length byte
    lpszFileName += *lpszFileName - 1;

    // If we're munging, added 0x30 to the last character value, otherwise
    // subtract 0x30.  0x30 is chosen completely at random.
    if ( fMunge )
        *lpszFileName += 0x30;
    else
        *lpszFileName -= 0x30;
    return 1;
}

//########################################################################
// This section watches calls to LoadModule and munges the EXE's module
// database as needed.
//########################################################################

HIDDEN NPHOOKCHILD npHookLoadModule = 0;
HIDDEN TFilename szOurFileName;
HIDDEN HINSTANCE HInstance;  

HINSTANCE
WINAPI
__export MultInst95LoadModule( LPCSTR lpszModuleName,
                               LPVOID lpvParameterBlock )
{
    HINSTANCE retValue;

    // Uppercase the name of the module name that was passed to LoadModule
    TFilename szNewFileName(lpszModuleName);
    szNewFileName.upper();

    // Compare the incoming filename to our EXE's module name.  If they
    // don't match, we don't need to bother munging the module database
    BOOL fSecondInstance = szOurFileName.find(szNewFileName) >= 0;

    // Unhook our LoadModule hook so that we can call the real LoadModule
    ProcUnhook( npHookLoadModule );

    // Munge module database if needed
    if ( fSecondInstance )
        MungeModuleHeader( HInstance, TRUE );

    // Call the original LoadModule code
    retValue = LoadModule( lpszModuleName, lpvParameterBlock );

    // Unmunge module database if needed
    if ( fSecondInstance )
        MungeModuleHeader( HInstance, FALSE );

    // Reinstall our LoadModule hook so that we see future loads
    ProcHook( npHookLoadModule );
    
    return retValue;
}

///////////////////////////////////////////////////////////
// Win16 event hook
///////////////////////////////////////////////////////////

const word WM_WAKEUP = RegisterWindowMessage("WAKEUP");
HTASK _waiting_for = 0xFFFF;

HIDDEN BOOLEAN event_hook(HWND hwnd,
                          UINT msg,
                          UINT wparam,
                          ULONG lparam,
                          long* ret)
{
  switch(msg)     
  {      
#ifndef ATTR_WIN_USE_CTL3D
  case WM_SYSCOLORCHANGE:
    Ctl3dColorChange();
    break;
#endif    
  case WM_MENUCHAR:
    if (wparam > ' ' && wparam <= 'z')
    {
      WINDOW win = cur_win();
      if (win != NULL_WIN)
      {                   
        const KEY key = toupper(wparam)+K_CTRL;
        dispatch_e_char(win, key);
        *ret = 2 << 16;
      }  
    }   
    break;  
  case WM_KEYDOWN:
    if (wparam == VK_F1)
    {
      if ((lparam & (1<<29)) == 0)             // Il tasto alt non e' premuto
      {
        KEY k = K_F1;
        
        int sc = GetAsyncKeyState(VK_CONTROL); // Stato del tasto control 
        if (sc & 0x8000) k += K_CTRL;
        
        int ss = GetAsyncKeyState(VK_SHIFT);   // Stato del tasto shift 
        if (ss & 0x8000) k += K_SHIFT;

        WINDOW win = cur_win();
        if (win != NULL_WIN)
          dispatch_e_char(win, k);
      }  
    }
    break;
  default:  
    if (msg == WM_WAKEUP)
    {
      if (wparam == _waiting_for)
        _waiting_for = 0xFFFF;
    }    
    break;
  }    

  return TRUE; // Continua col processo normale
}

///////////////////////////////////////////////////////////
// Operating system dependent functions
///////////////////////////////////////////////////////////

bool os_allow_another_instance()
{ 
  if ( npHookLoadModule )
      return TRUE;

#ifdef DBG
  bool noMunge = getenv("NOMUNGE") != NULL;
  if (noMunge) 
    return FALSE;
#endif
      
#ifndef ATTR_WIN_USE_CTL3D
    Ctl3dRegister(HInstance);
    Ctl3dAutoSubclass(HInstance);
#endif    
      
  HInstance = (HINSTANCE)xvt_vobj_get_attr(NULL_WIN, ATTR_WIN_INSTANCE);

  // Get the EXE's filename into a global string variable and uppercase it
  GetModuleFileName( HInstance, szOurFileName.get_buffer(), szOurFileName.size() );
  szOurFileName.upper();

  // Create a MakeProcInstance thunk so that our callback function
  // will always be using the correct DS selector
  FARPROC lpfnMPI
      = MakeProcInstance( (FARPROC)MultInst95LoadModule, HInstance );

  if ( !lpfnMPI )
      return FALSE;

  // Call PROCHOOK.DLL to hook calls to LoadModule
  npHookLoadModule = SetProcAddress(  (FARPROC)LoadModule,
                                      lpfnMPI, FALSE );
    
  return npHookLoadModule != NULL;
}

COLOR os_choose_color(COLOR col, WINDOW win)
{
  CHOOSECOLOR cc;
  memset(&cc, 0, sizeof(cc));            // Azzera struttura 

  if (win == NULL_WIN) win = TASK_WIN;   // Sceglie una finestra valida
  
  HWND hwnd = (HWND)xvt_vobj_get_attr(win, ATTR_NATIVE_WINDOW);
  HDC hdc = GetDC(hwnd);
  
  // Legge la palette di sistema 
  PALETTEENTRY* pe = NULL;
  int max_entries = 0;
  if (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE)
  {                             
    max_entries = GetDeviceCaps(hdc, SIZEPALETTE);
    pe = new PALETTEENTRY[max_entries];
    GetSystemPaletteEntries(hdc, 0, max_entries, pe);
  }
  ReleaseDC(hwnd, hdc);
  
  // Definisce i 16 colori customizzabili  
  unsigned long custom_colors[16];
  for (int c = 0; c < 16; c++)
  {
    if (pe)
    {     
      const PALETTEENTRY& e = pe[c < 8 ? c : max_entries - 16 + c];
      custom_colors[c] = RGB(e.peRed, e.peGreen, e.peBlue);
    }
    else    
    {
      const unsigned char val   = (c & 0x8) ? 255 : 127;
      const unsigned char red   = (c & 0x1) ? val : 0;
      const unsigned char green = (c & 0x2) ? val : 0;
      const unsigned char blue  = (c & 0x4) ? val : 0;
      custom_colors[c] = RGB(red, green, blue);
    }  
  }
  if (pe) 
  {
    delete pe;
    pe = NULL;
  }  
    
  cc.lStructSize  = sizeof(cc);               // Setta dimensioni
  cc.hwndOwner    = hwnd;                     // Setta finestra padre
  cc.rgbResult    = RGB(XVT_COLOR_GET_RED(c), XVT_COLOR_GET_GREEN(c), XVT_COLOR_GET_BLUE(c));
  cc.lpCustColors = custom_colors;            // Fissa colori custom
  cc.Flags        = CC_RGBINIT;               // Usa col come primo colore 
    
  if (ChooseColor(&cc) != 0)
    col = RGB2COLOR(GetRValue(cc.rgbResult), GetGValue(cc.rgbResult), GetBValue(cc.rgbResult));
  else
    col = COLOR_INVALID;
  return col;  
}

bool os_deny_another_instance()
{ 
  if ( !npHookLoadModule )
      return FALSE;
  SetProcRelease( npHookLoadModule );
  npHookLoadModule = 0;
  
#ifndef ATTR_WIN_USE_CTL3D
    Ctl3dUnregister(HInstance);
#endif    
    
  return TRUE;
}

bool os_destroy_native_icon(unsigned icon)
{
  return DestroyIcon((HICON)icon) != 0;
}

void os_draw_native_icon(WINDOW win, const RCT& rct, unsigned icon)
{  
  HDC hdc = (HDC)xvt_vobj_get_attr(win, ATTR_NATIVE_GRAPHIC_CONTEXT);
  int x = rct.left + (rct.right - rct.left - 32) / 2;
  int y = rct.top + (rct.bottom - rct.top - 32) / 2;
  DrawIcon(hdc, x, y, (HICON)icon);
}

unsigned long os_get_free_memory()
{
  return GetFreeSpace(0);
}

bool os_is_removable_drive(const char* path)
{            
  bool yes = path[1] == ':';
  if (yes)   
    yes = GetDriveType(toupper(path[0]) - 'A') == DRIVE_REMOVABLE;
  return yes;
}

bool os_is_network_drive(const char* path)
{
  bool yes = path[1] == ':';
  if (yes)   
    yes = GetDriveType(toupper(path[0]) - 'A') == DRIVE_REMOTE;
  return yes;
}

bool os_is_fixed_drive(const char* path)
{
  bool yes = path[1] == ':';
  if (yes)   
    yes = GetDriveType(toupper(path[0]) - 'A') == DRIVE_FIXED;
  return yes;
}

bool os_test_disk_free_space(const char* path, unsigned long filesize)
{
  int disk = 0;
  if (path && *path && path[1] == ':')
  {
    const char letter = toupper(path[0]);
    disk = 'A' - letter + 1;
  }  
  struct _diskfree_t drive;
  _dos_getdiskfree(disk, &drive);
    
  const unsigned requested_clusters = unsigned(filesize / drive.sectors_per_cluster / drive.bytes_per_sector) + 1;
  bool space_ok = requested_clusters <= drive.avail_clusters;
  return space_ok;
}

void  os_exec_help_command(MENU_TAG tag, const char* key)
{
  TFilename hlp("prassi.hlp");
  TString mod(key); 
  if (mod.not_empty())
  {
    mod.cut(2); mod.lower();
    if (mod != "ba") 
      hlp.insert(mod, 0);
  }
  else
  {
    if (tag == M_HELP_ONCONTEXT)
      tag = M_HELP_CONTENTS;
  }
    
  HWND hwnd = (HWND)xvt_vobj_get_attr(TASK_WIN, ATTR_NATIVE_WINDOW);
  switch(tag)
  {                     
  case M_HELP_CONTENTS: WinHelp(hwnd, hlp, HELP_CONTENTS, 0); break;
  case M_HELP_SEARCH: WinHelp(hwnd, hlp, HELP_PARTIALKEY, (DWORD)""); break;
  case M_HELP_HELPONHELP: WinHelp(hwnd, hlp, HELP_HELPONHELP, 0); break;
  case M_HELP_ONCONTEXT:
    if (hlp.exist())
    {
      struct MULTIGUY
      {
        UINT mkSize;
        BYTE mkKeylist;
        char mkKeyphrase[16];
      } mk;

      mk.mkSize = sizeof(MULTIGUY);
      mk.mkKeylist = 'M';
      strcpy(mk.mkKeyphrase, key);

      WinHelp(hwnd, hlp, HELP_MULTIKEY, (DWORD)&mk);
    }
    break;
  default: break;  
  }
}

int os_execute(const TFilename& path, bool sync, bool iconizetask, bool showchild)
{
  const int exitcode = WinExec(path, showchild ? SW_SHOWNORMAL : SW_HIDE);
  if (exitcode < 32)
  {
    switch (exitcode)
    {
    case 8:
      error_box("Risorse insufficienti per eseguire '%s'", (const char*)path); break;
    default:
      error_box("Impossibile eseguire '%s': %d", (const char*)path, exitcode); break;
    }
    return exitcode;
  }
  
  if (sync)
  { 
    TTemp_window tw(TASK_WIN);
    if (iconizetask)
    {
      tw.iconize();
      tw.deactivate();
    }  

    const char* szModule = path.name();
    HTASK child = NULL;
    TASKENTRY te; te.dwSize = sizeof(TASKENTRY); 
    for (bool ok = TaskFirst(&te); ok; ok = TaskNext(&te))
      if (te.hInst == (HINSTANCE)exitcode ||
          stricmp(te.szModule, szModule) == 0)
      {
        child = te.hTask;
        break;
      }  
          
    // Warning! child could be NULL if you run that beast called Foxpro        
    _waiting_for = child; 
    for (byte i = 0; _waiting_for == child; i++)
    {          
      // Esegue il controllo solo ogni 256 cicli
      if (i == 0 && ok && TaskFindHandle(&te, child) == FALSE) 
      {       
        _waiting_for = 0xFFFF; // Annulla attesa del processo
        break;
      }  
      xvt_app_process_pending_events();
    }
    
    if (iconizetask)
    {
      tw.maximize();
      tw.activate();             
    }  
        
    xvt_app_process_pending_events();
  }
  xvt_statbar_refresh();
  
  return 0;
}

bool os_spawn_by_menu()
{
  TASKENTRY te; te.dwSize = sizeof(TASKENTRY);
  HTASK ct = GetCurrentTask();
  TaskFindHandle(&te, ct);
  TaskFindHandle(&te, te.hTaskParent);
  bool yes = stricmp(te.szModule, "BA0") == 0 ||
#ifdef DBG
      stricmp(te.szModule, "CVW4") == 0 ||
      stricmp(te.szModule, "MSVC") == 0 ||
#endif
        stricmp(te.szModule, "Explorer") == 0 ||
        stricmp(te.szModule, "PROGMAN") == 0;
  return yes;      
}

int os_get_printer_names(TToken_string& t)
{
  char* buf = t.get_buffer(4096); // ammazzao'
  GetProfileString ("devices", NULL, "", buf, t.size());
  for (int i = 0; i < t.size(); i++)
  {
    if (buf[i] == '\0')
    {
      if (buf[i+1] != '\0') buf[i] = t.separator();
      else break;
    }  
  }
  return t.items();
}

bool os_set_default_printer(const char* name)
{                  
  CHECK(name && *name > ' ', "Null printer name");
  TString pdev(name);
  if (pdev.find(',') < 0)
  {
    TString szDevice(256);  
    GetProfileString ("devices", pdev, "", szDevice.get_buffer(), szDevice.size());
    pdev << ',' << szDevice;
  }  
  bool ok = WriteProfileString("windows", "device", pdev) != 0;  
  return ok;  
}

bool os_get_default_printer(TString& name)
{
  char* buf = name.get_buffer(128);
  bool ok = GetProfileString ("windows", "device", ",,,", buf, name.size()) != 0;
  return ok;
}

bool os_get_image_editor_path(TFilename& name)
{
  // where is EasyDoc installed?                 
  GetPrivateProfileString("Easydoc", "Path", "\\EASYDOC", 
                          name.get_buffer(), name.size(), 
                          "EasyDoc.ini");  

  // You're unlucky there is no EasyDoc
  if (name.empty())
    return FALSE;
  
  // paste EasyDoc path
  name.add("easydoc.exe");    
  
  // is EasyDoc present?
  bool ok = name.exist();
  return ok;
}

os_type os_get_type()
{
  const WORD winver = LOWORD(GetVersion());
  const BYTE majver = LOBYTE(winver);
  const BYTE minver = HIBYTE(winver);
  if (majver > 3 || (majver == 3 && minver > 11))
    return os_Windows95;
  const DWORD winflags = GetWinFlags();
  if (winflags & 0x4000)  
    return os_WindowsNT;
  return os_Windows;  
}

void os_post_menu_event(WINDOW win, MENU_TAG tag)
{
  HWND w = (HWND)xvt_vobj_get_attr(win, ATTR_NATIVE_WINDOW);
  PostMessage(w, WM_COMMAND, tag, 0L);
}

void os_set_event_hook()
{
  xvt_vobj_set_attr(NULL_WIN, ATTR_EVENT_HOOK, (long)event_hook); 

#ifdef ATTR_WIN_USE_CTL3D
  xvt_vobj_set_attr(NULL_WIN, ATTR_WIN_USE_CTL3D, TRUE);
#endif  

  long twin_style = WSF_ICONIZABLE | WSF_CLOSE | WSF_SIZE;  
  const int scx = GetSystemMetrics(SM_CXSCREEN);
  if (scx == 640 && os_get_type() == os_Windows95)
  {
    const int scy = GetSystemMetrics(SM_CYSCREEN);
    const int bcx = GetSystemMetrics(SM_CXFRAME); 
    const int bcy = GetSystemMetrics(SM_CYFRAME);
    static RCT rct;
    rct.left   = -bcx;
    rct.top    = GetSystemMetrics(SM_CYCAPTION)-bcy-1;
    rct.right  = scx+bcx;
    rct.bottom = scy+bcy;
    xvt_vobj_set_attr(NULL_WIN, ATTR_WIN_PM_TWIN_STARTUP_RCT, long(&rct));
  }
  else
    twin_style |= WSF_MAXIMIZED;  
  
  xvt_vobj_set_attr(NULL_WIN,ATTR_WIN_PM_TWIN_STARTUP_STYLE, twin_style);
}

void os_wake_up_caller()
{
  const HTASK ht = GetCurrentTask();
//  SendMessage(HWND_BROADCAST, WM_WAKEUP, (WPARAM)ht, 0L);
  PostMessage(HWND_BROADCAST, WM_WAKEUP, (WPARAM)ht, 0L);

  HWND hwnd = (HWND)xvt_vobj_get_attr(TASK_WIN, ATTR_NATIVE_WINDOW);
  WinHelp(hwnd, "prassi.hlp", HELP_QUIT, 0L);

  do_events();
}


bool os_file_exist(const char* file)
{
  HFILE hf = _lopen(file, READ);
  bool ok = hf != HFILE_ERROR;
  if (ok)
    _lclose(hf);
  return ok;  
}  

bool os_open_spool_row(const char* device)
{
  return TRUE;
}

bool os_spool_row(const char* str)
{
  return SpoolRow((char*)str, strlen(str)) != 0;
}

bool os_close_spool_row()
{
  return TRUE;
}

void os_iconize_window(WINDOW win)
{
  HWND hwnd = (HWND)xvt_vobj_get_attr(win, ATTR_NATIVE_WINDOW);
  ShowWindow(hwnd, SW_MINIMIZE);
}

void os_maximize_window(WINDOW win)
{
  HWND hwnd = (HWND)xvt_vobj_get_attr(win, ATTR_NATIVE_WINDOW);
  ShowWindow(hwnd, SW_SHOWMAXIMIZED);
}