dlg_newshell.c

very famous terminal, i use it test cli in vxworks many times, very useful

/*
 * mShell
 * Copyright 2006, Julien Lecomte
 *
 * This software is provided 'as-is', without any express or implied warranty.
 * In no event will the authors be held liable for any damages arising from the
 * use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *   1. The origin of this software must not be misrepresented; you must not
 * claim that you wrote the original software. If you use this software in a
 * product, an acknowledgment in the product documentation would be appreciated
 * but is not required.
 *   2. Altered source versions must be plainly marked as such, and must not
 * be misrepresented as being the original software.
 *   3. This notice may not be removed or altered from any source distribution.
 *
 * $Id: dlg_newshell.c,v 1.2 2006/04/06 10:56:57 julienlecomte Exp $
 */

#include "mshell_preconfig.h"

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <shlwapi.h>

#include "mshell_resource.h"
#include "mshell.h"
#include "dlg_newshell_tabs.h"

#define DISABLE_ENVCHKBOX(str,id) \
  if ((GetEnvironmentVariable (str, NULL, 0) == 0) && \
    (GetLastError() == ERROR_ENVVAR_NOT_FOUND)) \
    EnableWindow (GetNewShellTabDlgItem (id), FALSE);

#define CHECKBOX_CHECKED(id) \
  (IsWindowEnabled (GetNewShellTabDlgItem (id)) && \
  (SendMessage (GetNewShellTabDlgItem (id), BM_GETCHECK, 0, 0) == BST_CHECKED))

/* Meanings are inversed, ie:
 * InheritHome=1 means click the checkbox */
#define CHECKBOX_VALUE(id) \
  (SendMessage (GetNewShellTabDlgItem (id), BM_GETCHECK, 0, 0) == BST_CHECKED) == TRUE ? TEXT("1") : TEXT("0")

#define SETCHECKBOX_VALUE(id, cfg, section, file) \
  SendMessage (GetNewShellTabDlgItem (id), \
    GetPrivateProfileInt (cfg, TEXT(section), 0, file) == 0 ? BST_UNCHECKED : BM_SETCHECK, BST_CHECKED, 0);

TCHAR szConfig[MAX_PATH] = "Default";
extern TCHAR szPathSystem[];
static LPCTSTR lpPreciousVars[] = {
  TEXT("TMP"), TEXT("TEMP"), TEXT("PATH"), TEXT("HOME"),
  TEXT("SYSTEMROOT"), /* required for internet connection */
  /* Is SYSTEMDRIVE required for something ? */
  TEXT("")
};

static BOOL IsPrecious (LPTSTR lpVar)
{
  unsigned int i = 0;
  while (*lpPreciousVars[i])
  {
    if (StrCmpI (lpVar, lpPreciousVars[i]) == 0)
      return TRUE;
    i++;
  }
  return FALSE;
}

static void LoadConfig (void)
{
  TCHAR szPath[MAX_PATH];
  CopyMemory (szPath, szPathSystem, sizeof(TCHAR) * MAX_PATH);
  PathCombine (szPath, szPath, "etc\\mshell.ini");

  SETCHECKBOX_VALUE (ID_ENV_INHPATH, szConfig, "InheritPath", szPath);
  SETCHECKBOX_VALUE (ID_ENV_INHHOME, szConfig, "InheritHome", szPath);
  SETCHECKBOX_VALUE (ID_ENV_USERHOME, szConfig, "UserHome", szPath);
  SETCHECKBOX_VALUE (ID_ENV_INHERIT, szConfig, "InheritEnv", szPath);
}

static void SaveConfig (void)
{
  TCHAR szPath[MAX_PATH];
  CopyMemory (szPath, szPathSystem, sizeof(TCHAR) * MAX_PATH);
  PathCombine (szPath, szPath, "etc\\mshell.ini");

  WritePrivateProfileString (szConfig, "InheritPath", (CHECKBOX_VALUE (ID_ENV_INHPATH)), szPath);
  WritePrivateProfileString (szConfig, "InheritHome", (CHECKBOX_VALUE (ID_ENV_INHHOME)), szPath);
  WritePrivateProfileString (szConfig, "UserHome", (CHECKBOX_VALUE (ID_ENV_USERHOME)), szPath);
  WritePrivateProfileString (szConfig, "InheritEnv", (CHECKBOX_VALUE (ID_ENV_INHERIT)), szPath);
}

static void AddEnvVar (LPVOID lpEnvBlock, LPTSTR szVar, LPTSTR szValue, int *lpEnvSize, int *lpCurSize)
{
  /* Leave space for trailing null chars + '=' char */
  /* FIXME, we might need to resize lpEnvBlock */

  int dwEnvVarLen = (strlen (szVar) + strlen (szValue) + 3) * sizeof(TCHAR);
  if ((*lpCurSize + dwEnvVarLen) >= *lpEnvSize)
  {
    abort ();
#if 0
    *lpEnvSize = *lpEnvSize + XXXX;
    XXXX = HeapReAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, lpEnvBlock, *lpEnvSize * sizeof(TCHAR));
#endif
  }
  StrCatBuff (lpEnvBlock, szVar, *lpEnvSize);
  StrCatBuff (lpEnvBlock, TEXT("="), *lpEnvSize);
  StrCatBuff (lpEnvBlock, szValue, *lpEnvSize);
  /* temporarly use a tab char to mark where null chars will go */
  StrCatBuff (lpEnvBlock, TEXT("\t"), *lpEnvSize);
}

static void CopyEnvVar (LPVOID lpEnvBlock, LPTSTR szVar, int *lpEnvSize, int *lpCurSize)
{
  DWORD nSize = GetEnvironmentVariable (szVar, NULL, 0);
  if (nSize == 0)
  {
    if (GetLastError () != ERROR_ENVVAR_NOT_FOUND)
      AddEnvVar (lpEnvBlock, szVar, TEXT(""), lpEnvSize, lpCurSize);
    return;
  }

  LPTSTR szValue = (LPTSTR) HeapAlloc (GetProcessHeap (), 0, nSize * sizeof(TCHAR));
  if (!szValue)
    return; /* skip it */
  DWORD nRet = GetEnvironmentVariable (szVar, szValue, nSize);

  if (nRet == nSize-1) /* did we get the full thing ? otherwise skip */
    AddEnvVar (lpEnvBlock, szVar, szValue, lpEnvSize, lpCurSize);
  HeapFree (GetProcessHeap (), 0, szValue);
}

static BOOL DupEnvVar (LPVOID lpEnvBlock, LPTSTR szVar, LPTSTR szDupVar, int *lpEnvSize, int *lpCurSize)
{
  DWORD nSize = GetEnvironmentVariable (szDupVar, NULL, 0);
  if (nSize == 0)
    return FALSE;

  LPTSTR szValue = (LPTSTR) HeapAlloc (GetProcessHeap (), 0, nSize * sizeof(TCHAR));
  if (!szValue)
    return FALSE; /* skip it */
  DWORD nRet = GetEnvironmentVariable (szDupVar, szValue, nSize);

  if (nRet == nSize-1) /* did we get the full thing ? otherwise skip */
    AddEnvVar (lpEnvBlock, szVar, szValue, lpEnvSize, lpCurSize);
  HeapFree (GetProcessHeap (), 0, szValue);
  return TRUE;
}

static BOOL SetUserChoices (LPTERMINAL_INFO lpTI, HWND hMsgBox)
{
  /* Set environment block */
  int envsize = 2048;
  int envpos  = 0;

  lpTI->lpEnv = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, envsize * sizeof(TCHAR));
  if (!lpTI->lpEnv)
    return FALSE;

  if (lpTI->ismsys == TRUE)
    AddEnvVar (lpTI->lpEnv, STR_ENV_MSYSTEM, STR_ENV_MSYS, &envsize, &envpos);
  else if (lpTI->ismingw == TRUE)
    AddEnvVar (lpTI->lpEnv, STR_ENV_MSYSTEM, STR_ENV_MINGW, &envsize, &envpos);

  /* Copy precious environment */
  CopyEnvVar (lpTI->lpEnv, STR_ENV_SYSROOT, &envsize, &envpos);
  CopyEnvVar (lpTI->lpEnv, STR_ENV_TEMP, &envsize, &envpos);
  CopyEnvVar (lpTI->lpEnv, STR_ENV_TMP, &envsize, &envpos);

  /* User preferences */
  /* Inherit Windows $PATH */
  if (!CHECKBOX_CHECKED (ID_ENV_INHPATH))
    CopyEnvVar (lpTI->lpEnv, STR_ENV_PATH, &envsize, &envpos);

  /* Use USERPROFILE as HOME */
  if (CHECKBOX_CHECKED (ID_ENV_USERHOME))
  {
    if (  (DupEnvVar (lpTI->lpEnv, STR_ENV_HOME, STR_ENV_USRPROF, &envsize, &envpos) == FALSE)
       && (!CHECKBOX_CHECKED (ID_ENV_INHHOME)))
    {
      /* Falling back to inherit HOME */
      MessageBox (hMsgBox, "Could not inherit USERPROFILE, falling back to inheriting HOME.", STR_MSHELL, MB_OK | MB_ICONINFORMATION);
      CopyEnvVar (lpTI->lpEnv, STR_ENV_HOME, &envsize, &envpos);
    }
  }
  /* Use current HOME as HOME */
  else if (!CHECKBOX_CHECKED (ID_ENV_INHHOME))
    CopyEnvVar (lpTI->lpEnv, STR_ENV_HOME, &envsize, &envpos);

  /* Inherit all the rest but the precious ones which were allready treated. */
  if (!CHECKBOX_CHECKED (ID_ENV_INHERIT))
  {
    LPVOID lpEnv = GetEnvironmentStrings ();
    if (lpEnv)
    {
      LPTSTR lpVar;
      for (lpVar = (LPTSTR) lpEnv; *lpVar; lpVar++)
      {
        LPTSTR lpPos = lpVar;
        while (*lpPos)
        {
          if (*lpPos == '=')
          {
            *lpPos = '\0';
            *lpPos++;
            break;
          }
          else
            *lpPos++;
        }
        if (!IsPrecious (lpVar))
          CopyEnvVar (lpTI->lpEnv, lpVar, &envsize, &envpos);
        lpVar = &lpVar[sizeof(TCHAR) * (strlen (lpVar) + strlen (lpPos) + 1)];
      }
      FreeEnvironmentStrings (lpEnv);
    }
  }

  /* Fix environment block, ie, remove tabs and set them to NULL bytes */
  LPTSTR lpEnvChar = lpTI->lpEnv;
  while (*lpEnvChar)
  {
    if (*lpEnvChar == '\t')
      *lpEnvChar = '\0';
    *lpEnvChar++;
  }
  return TRUE;
}

static void DisableUserChoices (void)
{
  /* This should never happen, but what the hell... */
  DISABLE_ENVCHKBOX (STR_ENV_PATH, ID_ENV_INHPATH);
  /* If no HOME found, disable checkbox */
  DISABLE_ENVCHKBOX (STR_ENV_HOME, ID_ENV_INHHOME);
  /* If no USERPROFILE found, then wonder... and disable checkbox */
  DISABLE_ENVCHKBOX (STR_ENV_USRPROF, ID_ENV_USERHOME);
}

INT_PTR CALLBACK NewShellDlgProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
  switch (msg)
  {
    case WM_INITDIALOG:
    {
      InitDlgFont (hWnd);
      InitDlgCenter (hWnd);

      /* Populate our combos */
      if (!PopulateShells (GetDlgItem (hWnd, CMB_SHELL)))
      {
        MessageBox (hWnd, TEXT("Could not find any shells."), TEXT(PACKAGE_NAME), MB_OK | MB_ICONERROR | MB_SETFOREGROUND);
        EndDialog (hWnd, 0);
        return TRUE;
      }

      /* Find size of tab bar */
      CreateNewShellTabbar (GetDlgItem (hWnd, TAB_PREFS));

      DisableUserChoices ();
      LoadConfig ();
      return TRUE;
    }

    case WM_COMMAND:
      switch (LOWORD(wParam))
      {
        case BTN_MINGW:
        case BTN_MSYS:
        {
          BOOL nSuccess = FALSE;
          TERMINAL_INFO ti;
          if (LOWORD(wParam) == BTN_MSYS)
            ti.ismsys = TRUE;
          else
            ti.ismingw = TRUE;

          if (!SetUserChoices (&ti, hWnd))
            return FALSE;
          nSuccess = ValidateShellInfo (&ti, GetDlgItem (hWnd, CMB_SHELL), hWnd);
          if (ti.lpEnv)
            HeapFree (GetProcessHeap (), 0, ti.lpEnv);
          if (!nSuccess)
            return FALSE;

          SaveConfig ();
          EndDialog (hWnd, 0);
          return TRUE;
        }
      }
      return FALSE;

    case WM_DESTROY:
      DeleteNewShellTabbar ();
      return TRUE;

    case WM_NOTIFY:
    { /*
      LPNMHDR lpNotif = (LPNMHDR) lParam;
      if (lpNotif->hwndFrom == hwnds[HWND_TABBAR])
      {
        switch (lpNotif->code)
        {
          case TCN_SELCHANGE:
            ShowTab (lpNotif->hwndFrom);
            return TRUE;

          case TCN_SELCHANGING:
            HideTab (lpNotif->hwndFrom);
            return TRUE;
        }
      }
      */
      return TRUE;
    }

    case WM_SYSCOMMAND:
      if (wParam == SC_CLOSE)
      {
        EndDialog (hWnd, 0);
        return TRUE;
      }
      return FALSE;

    default:
      return FALSE;
  }
}