TaupieGUI.c

Aller à la documentation de ce fichier.

 
 
 
 
#include <sys/stat.h>
#include <stdio.h>
#include <locale.h>
#include <ctype.h>
#include <time.h>
#include <math.h>
#include <stdint.h>
#include <wchar.h>
 
#include <_mingw.h>
#include <ole2.h>
#include <windows.h>
#include <winreg.h>
#include <windowsx.h>
#include <uxtheme.h>
#include <shlobj.h>
#include <commctrl.h>
 
#include "../_TkT2/Defines.h"
 
#include "../_TkT2/EasyErrors.h"
#include "../_TkT2/EasyWin32.h"
#include "../_TkT2/EasyFiles.h"
#include "../_TkT2/FormatNumber.h"
#include "../_TkT2/ProgressBar.h"
#include "../_TkT2/ReadArchive.h"
#include "../_TkT2/EasyDecode.h"
#include "../_TkT2/EasyListView.h"
#include "../_TkT2/EasyAbout.h"
#include "../_TkT2/EasyDPI.h"
#include "../_TkT2/EasyCSV.h"
#include "../_TkT2/ReadFile.h"
#include "../_TkT2/EasyString.h"
 
#include "../_TkT2/ManageSQLite.h"
#include "../_TkT2/ManageSQLite_Win32.h"
 
#include "locales.h"
#include "TaupieGUI.h"
 
#include "extra.h"
 
#include "resource.h"
 
 
 
 
static HWND hMainDataView;
static HWND hMainProjectTree;
static HWND hMainStatusBar;
 
static HWND hMainQueryError;
static HWND hMainQueryEdit;
static HWND hMainQueryExecute;
 
static RECT rProjectTree;
static RECT rDataView;
 
#define SCROLL_TIMER_ID    1
#define SCROLL_IDLE_MS   100
static UINT_PTR scrollingTimer;
 
#define NBROWS_TIMER_ID    2
#define NBROWS_IDLE_MS  1000
//static UINT_PTR countingTimer;
 
static wchar_t *currentCommand;
static wchar_t *originalCommand;
 
static sqlite3 *currentDataBase;
static wchar_t *currentDataBaseName;
static wchar_t *currentSelectedTable;
 
static HTREEITEM hActualSelectedTableItem;
static LVHITTESTINFO selectedCellInfo;
 
static HFONT mainVariableFont;
static HFONT mainFixedFont;
static HFONT mainFixedBlackFont;
 
static int xTableView;
static int xQueryEdit;
 
static wchar_t *sqlError;
 
static int freezeDataView;
 
#define DATAVIEW_MAXROWS 100000000
static int dataViewPage;
static int64_t dataViewNbRows;
 

void SetVisibility(int project, int table, int query __attribute__((unused)))
{
  if (project == HIDE)
    {
      ShowWindow(hMainProjectTree, SW_HIDE);
    }
  else if (project == SHOW)
    {
      ShowWindow(hMainProjectTree, SW_SHOW);
    }
 
  if (table == HIDE)
    {
      ShowWindow(hMainDataView, SW_HIDE);
    }
  else if (table == SHOW)
    {
      ShowWindow(hMainDataView, SW_SHOW);
      //AutosizeColumns(hMainDataView, 0);
    }
 
  if (query == HIDE)
    {
      ShowWindow(hMainQueryError, SW_HIDE);
      ShowWindow(hMainQueryEdit, SW_HIDE);
      ShowWindow(hMainQueryExecute, SW_HIDE);
    }
  else if (query == SHOW)
    {
      ShowWindow(hMainQueryError, SW_SHOW);
      ShowWindow(hMainQueryEdit, SW_SHOW);
      ShowWindow(hMainQueryExecute, SW_SHOW);
    }
}
 

int ProjectTree_SelectTableByName(const wchar_t *tableName)
{
  int result = -1;
 
  if (tableName && tableName[0])
    {
      HTREEITEM hitem = TreeView_GetRoot(hMainProjectTree);
 
      hitem = TreeView_GetChild(hMainProjectTree, hitem);
 
      TV_ITEM item;
 
      if (hitem)
        {
          wchar_t text[0x100];
 
          do
            {
              while (1)
                {
                  item.mask = TVIF_PARAM | TVIF_TEXT;
                  item.lParam = 0;
                  item.pszText = text;
                  item.cchTextMax = _countof(text);
                  item.hItem = hitem;
 
                  if (TreeView_GetItem(hMainProjectTree, &item) == TRUE)
                    {
                      if (item.lParam == PROJECTTREE_TABLELIST)
                        {
                          hitem = TreeView_GetChild(hMainProjectTree, hitem);
                          continue;
                        }
                    }
 
                  break;
                }
 
              if (!wcsicmp(tableName, text))
                {
                  TreeView_SelectItem(hMainProjectTree, hitem);
                  result = 0;
                  break;
                }
            }
          while ((hitem = TreeView_GetNextSibling(hMainProjectTree, hitem)));
        }
    }
 
  return result;
}
 

int64_t ProjectTree_Update(HWND hwnd)
{
  int64_t nbItems = -1;
 
  if (currentDataBaseName)
    {
      int result = SQLITE_OK;
 
      if (!currentDataBase)
        {
          result = OpenSQLiteDB(&currentDataBase, currentDataBaseName, FALSE);
        }
 
      if (result == SQLITE_OK)
        {
          const wchar_t *name = GetStrictFileName(currentDataBaseName);
          nbItems = FillATreeView_Win32(hwnd, &hMainProjectTree, name, currentDataBase);
 
          if (hMainProjectTree)
            {
              //ApplyDarkMode(hMainProjectTree, L"DarkMode_Explorer");
 
              SetWindowRedraw(hMainProjectTree, FALSE);
 
              SetWindowPos(hMainProjectTree,
                           HWND_TOP,
                           rProjectTree.left,
                           rProjectTree.top,
                           rProjectTree.right - rProjectTree.left,
                           rProjectTree.bottom - rProjectTree.top,
                           0);
 
              SetWindowSubclass(hMainProjectTree, ProjectTree_Procedure, SUBCLASS_PROJECT_ID, 0);
 
              SetWindowRedraw(hMainProjectTree, TRUE);
 
              SetVisibility(SHOW, 0, SHOW);
            }
        }
    }
 
  return nbItems;
}
 

void StatusBar_Update(const wchar_t *tableName, int64_t records)
{
  if (tableName)
    {
      wchar_t buffer[MAX_BUF] = L"";
      swprintf(buffer, _countof(buffer), L"%ls%ls%ls",
               tableName, tableName[0] ? L" : " : L"",
               formater_nombre(0, records, L' ', 0, 0));
 
      SetWindowText(hMainStatusBar, buffer);
    }
  else
    {
      SetWindowText(hMainStatusBar, L"");
    }
}
 

void Clean(void)
{
  DeleteLocalFile(SOFT_NAMEW, L"temp\\" LISTE_FICHIERS);
  DeleteLocalFile(SOFT_NAMEW, L"temp\\old" LISTE_FICHIERS);
 
  DeleteLocalFile(SOFT_NAMEW, ARCHIVE_INFO);
  DeleteLocalDirectory(SOFT_NAMEW, ARCHIVE_FOLDER);
 
  DeleteLocalDirectory(SOFT_NAMEW, L"temp");
}
 

void Main_OnPaint(HWND hwnd)
{
  PAINTSTRUCT ps;
  HDC hdc = BeginPaint(hwnd, &ps);
 
  RECT rect = {0};
 
  if (!hMainProjectTree)
    {
      GetClientRect(hwnd, &rect);
    }
  else if (!hMainDataView)
    {
      rect = rDataView;
    }
 
  RECT rPaint;
 
  if (IntersectRect(&rPaint, &rect, &ps.rcPaint))
    {
      FillRect(hdc, &rPaint, GetSysColorBrush(COLOR_BTNFACE));
    }
 
  EndPaint(hwnd, &ps);
}
 

void Main_OnSize(HWND hwnd,
                 UINT state __attribute__((unused)),
                 UINT x,
                 UINT y)
{
  UINT width = 120;
 
  RECT rectSB;
  GetClientRect(hMainStatusBar, &rectSB);
  SetWindowPos(hMainStatusBar, HWND_TOP, 0, 0, 0, 0, 0);
 
  HTREEITEM hitem = TreeView_GetFirstVisible(hMainProjectTree);
 
  if (hitem)
    {
      do
        {
          RECT rect;
 
          if (TreeView_GetItemRect(hMainProjectTree, hitem, &rect, TRUE) == TRUE)
            {
              if ((UINT)rect.right > width)
                {
                  width = rect.right;
                }
            }
        }
      while ((hitem = TreeView_GetNextVisible(hMainProjectTree, hitem)));
    }
 
  width += 32;
 
  int bottom = y - rectSB.bottom;
 
  if (width > (x / 3))
    {
      width = x / 3;
    }
 
  rProjectTree.left = 0;
  rProjectTree.top = 0;
  rProjectTree.right = width;
  rProjectTree.bottom = bottom * 9 / 10;
 
  SetWindowPos(hMainProjectTree,
               HWND_TOP,
               0,
               0,
               width,
               bottom * 9 / 10,
               0);
 
  rDataView.left = width;
  rDataView.top = 0;
  rDataView.right = x;
  rDataView.bottom = bottom * 9 / 10;
 
  SetWindowPos(hMainDataView,
               HWND_TOP,
               width,
               0,
               x - width,
               bottom * 9 / 10,
               0);
 
  int queryHeight = bottom * 1 / 10;
 
  SetWindowPos(hMainQueryError,
               HWND_TOP,
               0,
               bottom - queryHeight,
               x / 3,
               queryHeight,
               0);
 
  SetWindowPos(hMainQueryEdit,
               HWND_TOP,
               x / 3,
               bottom - queryHeight,
               (x * 2 / 3) - BUTTON_SIZE,
               queryHeight,
               0);
 
  InvalidateRect(hwnd, NULL, TRUE);
  UpdateWindow(hwnd);
}
 

void QueryBar_Update(const wchar_t *errorMsg, const wchar_t *request)
{
  if (errorMsg)
    {
      SetWindowText(hMainQueryError, errorMsg);
    }
 
  if (request)
    {
      SetWindowText(hMainQueryEdit, request);
    }
}
 

LRESULT CALLBACK QueryExecute_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
                                        UINT_PTR uIdSubclass, DWORD_PTR dwRefData __attribute__((unused)))
{
  static HFONT hFont;
 
  switch (uMsg)
    {
      case WM_SHOWWINDOW :
        {
          RecreateDialogFont(hwnd, &hFont, VARIABLE_FONT, SIZE_OF_FONT * 2);
          ApplyFontToChildren(hwnd, hFont);
 
          break;
        }
 
      case WM_NCDESTROY :
        {
          if (hFont)
            {
              DeleteObject(hFont);
            }
 
          RemoveWindowSubclass(hwnd, QueryExecute_Procedure, uIdSubclass);
 
          break;
        }
 
      default :
        {
          break;
        }
    }
 
  return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}
 

LRESULT CALLBACK QueryEdit_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
                                     UINT_PTR uIdSubclass, DWORD_PTR dwRefData __attribute__((unused)))
{
  switch (uMsg)
    {
      case WM_WINDOWPOSCHANGING :
        {
          RestartScrollingTimer(GetParent(hwnd));
 
          WINDOWPOS *wp = (LPWINDOWPOS) lParam;
 
          if (!(wp->flags & (SWP_NOSIZE/* | SWP_NOMOVE*/)))
            {
              RECT r, rSB;
              GetClientRect(GetParent(hwnd), &r);
              GetClientRect(hMainStatusBar, &rSB);
 
              int bottom = r.bottom - rSB.bottom;
 
              if ((wp->x + wp->cx) != (r.right - BUTTON_SIZE))
                {
                  wp->cx = (r.right - BUTTON_SIZE) - wp->x;
                }
 
              if (wp->y > (bottom - BUTTON_SIZE))
                {
                  wp->y = bottom - BUTTON_SIZE;
                }
 
              wp->cy = bottom - wp->y;
 
              xQueryEdit = wp->x;
              SetWindowPos(hMainQueryError, 0, 0, wp->y, wp->x, wp->cy, SWP_NOSENDCHANGING);
              SetWindowPos(hMainQueryExecute, 0, (r.right - BUTTON_SIZE), wp->y, BUTTON_SIZE, wp->cy, SWP_NOSENDCHANGING);
 
              SetWindowPos(hMainDataView, 0, xTableView, 0, r.right - xTableView, bottom - wp->cy, SWP_NOSENDCHANGING);
 
              rDataView.left = xTableView;
              rDataView.top = 0;
              rDataView.right = r.right;
              rDataView.bottom = bottom - wp->cy;
 
              SetWindowPos(hMainProjectTree, 0, 0, 0, xTableView, bottom - wp->cy, SWP_NOSENDCHANGING);
 
              rProjectTree.left = 0;
              rProjectTree.top = 0;
              rProjectTree.right = xTableView;
              rProjectTree.bottom = bottom - wp->cy;
 
              return 0;
            }
 
          break;
        }
 
      case WM_NCDESTROY:
        {
          RemoveWindowSubclass(hwnd, QueryEdit_Procedure, uIdSubclass);
          break;
        }
 
      default :
        {
          break;
        }
    }
 
  return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}
 

LRESULT CALLBACK QueryError_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
                                      UINT_PTR uIdSubclass, DWORD_PTR dwRefData __attribute__((unused)))
{
  switch (uMsg)
    {
      case WM_WINDOWPOSCHANGING :
        {
          RestartScrollingTimer(GetParent(hwnd));
 
          WINDOWPOS *wp = (LPWINDOWPOS) lParam;
 
          if (!(wp->flags & (SWP_NOSIZE/* | SWP_NOMOVE*/)))
            {
              RECT r, rSB;
              GetClientRect(GetParent(hwnd), &r);
              GetClientRect(hMainStatusBar, &rSB);
 
              int bottom = r.bottom - rSB.bottom;
 
              //RECT rT;
              //GetWindowRect(hMainDataView, &rT);
 
              if (wp->x > 0)
                {
                  wp->cx += wp->x;
                  wp->x = 0;
                }
 
              if (wp->cx > (r.right - BUTTON_SIZE))
                {
                  wp->cx = r.right - BUTTON_SIZE;
                }
 
              if (wp->y > (bottom - BUTTON_SIZE))
                {
                  wp->y = bottom - BUTTON_SIZE;
                }
 
              wp->cy = bottom - wp->y;
 
              xQueryEdit = wp->cx;
              SetWindowPos(hMainQueryEdit, 0, wp->cx, wp->y, (r.right - BUTTON_SIZE) - wp->cx, wp->cy, SWP_NOSENDCHANGING);
              SetWindowPos(hMainQueryExecute, 0, (r.right - BUTTON_SIZE), wp->y, BUTTON_SIZE, wp->cy, SWP_NOSENDCHANGING);
 
              SetWindowPos(hMainDataView, 0, xTableView, 0, r.right - xTableView, bottom - wp->cy, SWP_NOSENDCHANGING);
 
              rDataView.left = xTableView;
              rDataView.top = 0;
              rDataView.right = r.right;
              rDataView.bottom = bottom - wp->cy;
 
              SetWindowPos(hMainProjectTree, 0, 0, 0, xTableView, bottom - wp->cy, SWP_NOSENDCHANGING);
 
              rProjectTree.left = 0;
              rProjectTree.top = 0;
              rProjectTree.right = xTableView;
              rProjectTree.bottom = bottom - wp->cy;
 
              return 0;
            }
 
          break;
        }
 
      case WM_NCDESTROY:
        {
          RemoveWindowSubclass(hwnd, QueryError_Procedure, uIdSubclass);
          break;
        }
 
      default :
        {
          break;
        }
    }
 
  return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}
 

void QueryBar_Create(HWND hwnd)
{
  hMainQueryEdit = CreateWindowEx(0, L"EDIT", TEXT(EMPTY_STRING),
                                  WS_CHILD | WS_VSCROLL | ES_AUTOVSCROLL | ES_MULTILINE | WS_THICKFRAME,
                                  0, 0, 0, 0, hwnd, 0, (HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), NULL);
 
  SetWindowSubclass(hMainQueryEdit, QueryEdit_Procedure, SUBCLASS_QUERYEDIT_ID, 0);
 
  //ApplyDarkMode(hMainQueryEdit, L"DarkMode_Explorer");
 
 
  hMainQueryExecute = CreateWindowEx(0, L"BUTTON", L"\u26A1",//L"\U0001F3B2",//L"\u2935",//L"\u2713",//L"\u23F5",//
                                     WS_CHILD | WS_BORDER | BS_PUSHBUTTON | BS_TEXT,
                                     0, 0, 0, 0, hwnd, (HMENU)IDM_SQL_QUERY, (HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), NULL);
 
  SetWindowSubclass(hMainQueryExecute, QueryExecute_Procedure, SUBCLASS_QUERYEXECUTE_ID, (DWORD_PTR)NULL);
 
  ApplyDarkMode(hMainQueryExecute, L"DarkMode_Explorer");
 
 
  hMainQueryError = CreateWindowEx(0, L"EDIT", TEXT(EMPTY_STRING),
                                   WS_CHILD | WS_VSCROLL | ES_AUTOVSCROLL | ES_MULTILINE | ES_READONLY | WS_THICKFRAME,
                                   0, 0, 0, 0, hwnd, 0, (HINSTANCE)GetWindowLongPtr(hwnd, GWLP_HINSTANCE), NULL);
 
  SetWindowSubclass(hMainQueryError, QueryError_Procedure, SUBCLASS_QUERYERROR_ID, 0);
 
  //ApplyDarkMode(hMainQueryError, L"DarkMode_Explorer");
}
 

BOOL Main_OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
{
  SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX | SEM_NOALIGNMENTFAULTEXCEPT);
 
  setlocale(LC_ALL, "French_France.1252");
 
  //SetCursor(LoadCursor(NULL, IDC_ARROW));
 
  srand(time(0));
 
  // application de l'icone
 
  SetClassLongPtr(hwnd, GCLP_HICON, (LONG_PTR)LoadIcon((HINSTANCE)GetModuleHandle(NULL), L"mainIcon"));
  SendMessage(hwnd, WM_SETICON, (WPARAM)LoadIcon((HINSTANCE)GetModuleHandle(NULL), L"mainIcon"), MAKELPARAM(FALSE, 0));
 
  // création de la barre de statut
 
  hMainStatusBar = CreateWindowEx(0, STATUSCLASSNAME, TEXT(EMPTY_STRING),
                                  WS_CHILD | WS_VISIBLE,
                                  0, 0, 0, 0, hwnd, 0, (HINSTANCE)GetWindowInstance(hwnd), NULL);
 
  StatusBar_Update(NULL, 0);
 
  // création des répertoires locaux
 
  wchar_t *appDir = GetLocalFile(SOFT_NAMEW, NULL);
 
  if (appDir)
    {
      _wmkdir(appDir);
      free(appDir);
    }
 
  wchar_t *tmpDir = GetLocalFile(SOFT_NAMEW, L"temp");
 
  if (tmpDir)
    {
      _wmkdir(tmpDir);
      free(tmpDir);
    }
 
  CreateInitFile(SOFT_NAMEW);
 
  QueryBar_Create(hwnd);
 
 
  HMENU hMenu = GetMenu(hwnd);
  HMENU hSubMenu = GetSubMenuByID(hMenu, IDP_HELP);
  SetSubMenuIcon(hSubMenu, IDM_ABOUT, L"mainIcon");
 
  DrawMenuBar(hwnd);
 
 
  ExtraInit(hwnd, lpCreateStruct);
 
 
  RecreateDialogFont(hwnd, &mainVariableFont, VARIABLE_FONT, SIZE_OF_FONT);
 
  // affiche le projet courant éventuel (s'il n'a pas été fermé lors de la précédente fermeture de l'application).
  PostMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDM_INIT, 0), (LPARAM) NULL);
 
  return TRUE;
}
 

void Main_OnClose(HWND hwnd)
{
  //if (MessageBoxA(hwnd, "\n  Voulez-vous quitter ?  \n", "Arrêt", MB_YESNO | MB_ICONQUESTION) == IDYES)
  {
    ShowWindow(hwnd, SW_HIDE);
 
    CloseSQLiteDB(&currentDataBase);
 
    Clean();
    PostQuitMessage(0);
 
    if (mainVariableFont)
      {
        DeleteObject(mainVariableFont);
        mainVariableFont = NULL;
      }
 
    if (mainFixedFont)
      {
        DeleteObject(mainFixedFont);
        mainFixedFont = NULL;
      }
 
    if (mainFixedBlackFont)
      {
        DeleteObject(mainFixedBlackFont);
        mainFixedBlackFont = NULL;
      }
  }
}
 

void ProjectTree_Enlarge(void)
{
  int width = 120;
 
  HTREEITEM hitem = TreeView_GetFirstVisible(hMainProjectTree);
  if (hitem)
    {
      do
        {
          RECT rect;
 
          if (TreeView_GetItemRect(hMainProjectTree, hitem, &rect, TRUE) == TRUE)
            {
              if (rect.right > width)
                {
                  width = rect.right;
                }
            }
        }
      while ((hitem = TreeView_GetNextVisible(hMainProjectTree, hitem)));
    }
 
  width += 32;
 
  RECT r;
  GetWindowRect(hMainProjectTree, &r);
 
  SetWindowPos(hMainProjectTree, HWND_TOP, 0, 0, width, r.bottom - r.top, SWP_DRAWFRAME);
}
 

void ProjectTree_Close(HWND hwnd)
{
  SaveOption(SOFT_NAMEW, SOFT_NAMEW, OPTION_CURRENTPROJECT, NULL);
 
  SetVisibility(HIDE, HIDE, HIDE);
  StatusBar_Update(NULL, 0);
 
  dataViewNbRows = 0;
 
  CloseSQLiteDB(&currentDataBase);
 
  if (hMainDataView)
    {
      DestroyWindow(hMainDataView);
      hMainDataView = NULL;
    }
 
  if (hMainProjectTree)
    {
      DestroyWindow(hMainProjectTree);
      hMainProjectTree = NULL;
    }
 
  HMENU hMenu = GetSubMenuByID(GetMenu(hwnd), IDM_PROJECT);
  if (hMenu)
    {
      EnableMenuItem(hMenu, IDM_PROJECT_UPDATE, MF_GRAYED);
      EnableMenuItem(hMenu, IDM_PROJECT_OPTIMIZE, MF_GRAYED);
      EnableMenuItem(hMenu, IDM_PROJECT_LOG_IMPORT, MF_GRAYED);
      EnableMenuItem(hMenu, IDM_PROJECT_LOG_COMMAND, MF_GRAYED);
      EnableMenuItem(hMenu, IDM_PROJECT_CLOSE, MF_GRAYED);
    }
 
  EnableMenuItem(GetMenu(hwnd), IDM_DATA, MF_GRAYED);
  EnableMenuItem(GetMenu(hwnd), IDM_SQL, MF_GRAYED);
 
  DrawMenuBar(hwnd);
 
  InvalidateRect(hwnd, NULL, TRUE);
  UpdateWindow(hwnd);
}
 

void ProjectTree_Open(HWND hwnd, int option)
{
  // récupération du nom du dernier projet ouvert
 
  wchar_t *projectName = calloc(FILENAMELENGTH_MAX, sizeof(wchar_t));
 
  if (projectName)
    {
      LoadOption(SOFT_NAMEW, SOFT_NAMEW, OPTION_CURRENTPROJECT, projectName, FILENAMELENGTH_MAX);
 
      // sauf initialisation, demande à l'utilisateur la base à utiliser
 
      BOOL testOK = FALSE;
 
      if ((option == IDM_INIT) || (option == IDM_PROJECT_CONVERT))
        {
          testOK = TRUE;
        }
      else
        {
          wchar_t *newProjectName = (option == IDM_PROJECT_NEW)
                                    ? FileOutChooserWithInit(TEXT(NEW_PROJECT), hwnd, TEXT(FILETYPE_PROJECT), projectName, FALSE)
                                    : FileInChooserWithInit(TEXT(OPEN_PROJECT), hwnd, TEXT(FILETYPE_ANY) TEXT(FILETYPE_PROJECT), projectName);
 
          // OK, si un nom de base valide est choisi, il est enregistré comme base courante.
 
          if (newProjectName)
            {
              testOK = TRUE;
 
              DataView_Close(hwnd);
              QueryBar_Update(L"", L"");
              ProjectTree_Close(hwnd);
 
              SaveOption(SOFT_NAMEW, SOFT_NAMEW, OPTION_CURRENTPROJECT, newProjectName);
              swprintf(projectName, FILENAMELENGTH_MAX, L"%ls", newProjectName);
              free(newProjectName);
            }
        }
 
      // si le projet courant est nouveau ou accessible en lecture/écriture, alors ouvre / crée le projet.
 
      if (testOK)
        {
          dataViewNbRows = 0;
 
          if ((option == IDM_PROJECT_NEW) || (!_waccess(projectName, R_OK | W_OK)))
            {
              int result = SQLITE_OK;
 
              CloseSQLiteDB(&currentDataBase);
              NullFree(currentDataBaseName);
 
              result = OpenSQLiteDB(&currentDataBase, projectName, FALSE);
 
              if (result == SQLITE_OK)
                {
                  currentDataBaseName = projectName;
                  projectName = NULL;
 
                  if ((option == IDM_PROJECT_NEW) || (option == IDM_PROJECT_CONVERT))
                    {
                      CreateTableInDB(currentDataBase, APP_FILES,
                                      TEXT(FIELD_TABLENAME) L" TEXT, "
                                      TEXT(FIELD_IMPORTDATE) L" DATE, " TEXT(FIELD_IMPORTTIME) L" TIME, "
                                      TEXT(FIELD_FILEPATH) L" TEXT, " TEXT(FIELD_FILENAME) L" TEXT, "
                                      TEXT(FIELD_FILESIZE) L" INT, "
                                      TEXT(FIELD_FILEDATE) L" DATE, " TEXT(FIELD_FILETIME) L" TIME"
                                     );
 
                      CreateTableInDB(currentDataBase, APP_HISTORY,
                                      TEXT(FIELD_RUNDATE) L" DATE, " TEXT(FIELD_RUNTIME) L" TIME, "
                                      TEXT(FIELD_ACTION) L" TEXT, "
                                      TEXT(FIELD_DOTCOMMAND) L" TEXT, "
                                      TEXT(FIELD_SQL) L" TEXT, "
                                      TEXT(FIELD_ERROR) L" TEXT"
                                     );
 
                      if (option == IDM_PROJECT_NEW)
                        {
                          int sizeDotCommand = wcslen(L".open --new ''") + wcslen(GetStrictFileName(currentDataBaseName)) + 1;
                          wchar_t *dotCommand = calloc(sizeDotCommand, sizeof(wchar_t));
                          if (dotCommand)
                            {
                              swprintf(dotCommand, sizeDotCommand, L".open --new \"%ls\"", GetStrictFileName(currentDataBaseName));
                              RecordExecutedAction(TEXT(LOG_TEXTCREATEPROJECT), dotCommand, NULL, NULL);
                            }
                        }
                    }
 
                  ProjectTree_Update(hwnd);
                  ProjectTree_Enlarge();
 
                  HMENU hMenu = GetSubMenuByID(GetMenu(hwnd), IDM_PROJECT);
                  if (hMenu)
                    {
                      EnableMenuItem(hMenu, IDM_PROJECT_UPDATE, MF_ENABLED);
                      EnableMenuItem(hMenu, IDM_PROJECT_OPTIMIZE, MF_ENABLED);
                      EnableMenuItem(hMenu, IDM_PROJECT_LOG_IMPORT, MF_ENABLED);
                      EnableMenuItem(hMenu, IDM_PROJECT_LOG_COMMAND, MF_ENABLED);
                      EnableMenuItem(hMenu, IDM_PROJECT_CLOSE, MF_ENABLED);
                    }
 
                  EnableMenuItem(GetMenu(hwnd), IDM_DATA, MF_ENABLED);
                  EnableMenuItem(GetMenu(hwnd), IDM_SQL, MF_ENABLED);
 
                  DrawMenuBar(hwnd);
                }
            }
          else
            {
              ProjectTree_Close(hwnd);
            }
        }
 
      if (projectName)
        {
          free(projectName);
        }
    }
}
 

void DataView_Close(HWND hwnd __attribute__((unused)))
{
  SetVisibility(0, HIDE, 0);
  StatusBar_Update(NULL, 0);
 
  if (hMainDataView)
    {
      DestroyWindow(hMainDataView);
      hMainDataView = NULL;
    }
}
 

int64_t ExecuteSQLScript(HWND hwnd, const wchar_t *fileName)
{
  int64_t nbRows = -1;
 
  wchar_t *command = NULL;
 
  NullFree(originalCommand);
  NullFree(currentCommand);
 
  HANDLE hProgressBar = StartProgressBar(L"Ex\351cution du script SQL", -1);
  nbRows = DataView_UpdateWithAFile(hwnd, &hMainDataView, &rDataView, &currentDataBase, &command, fileName);
  StopProgressBar(hProgressBar);
 
  currentCommand = _wcsdup(command ? command : L"");
 
  if (nbRows >= 0)
    {
      QueryBar_Update(L"", currentCommand);
      RecordExecutedAction(TEXT(LOG_TEXTRUNSQL), NULL, currentCommand, NULL);
 
      SetWindowSubclass(hMainDataView, DataView_Procedure, SUBCLASS_TABLE_ID, 0);
 
      originalCommand = _wcsdup(currentCommand);
 
      SetVisibility(0, SHOW, 0);
      StatusBar_Update((nbRows != INT32_MAX) ? L"" : NULL, nbRows);
    }
  else
    {
      QueryBar_Update(sqlError, currentCommand);
      RecordExecutedAction(TEXT(LOG_TEXTRUNSQL), NULL, currentCommand, sqlError);
 
      NullFree(currentCommand);
 
      DataView_Close(hwnd);
    }
 
  InvalidateRect(hwnd, NULL, TRUE);
  UpdateWindow(hwnd);
 
  ShowWindow(hMainDataView, SW_SHOWNA);
 
  return nbRows;
}
 

int64_t ExecuteCustomSQLQuery(HWND hwnd)
{
  int64_t nbRows = -1;
 
  int length = GetWindowTextLength(hMainQueryEdit);
  wchar_t *command = calloc(length + 1, sizeof(wchar_t));
 
  if (command)
    {
      GetWindowText(hMainQueryEdit, command, length + 1);
 
      NullFree(originalCommand);
      NullFree(currentCommand);
      currentCommand = _wcsdup(command);
 
      HANDLE hProgressBar = StartProgressBar(L"Ex\351cution de la requ\350te", -1);
      wchar_t *firstLetters = AllTrim(command, L" \t\r\n", TRUE, FALSE, FALSE);
      int useTmp = wcsnicmp(firstLetters, L"SELECT", 6) ? USE_NO_TEMP : USE_TEMP_TABLE;
      nbRows = DataView_Update(hwnd, &hMainDataView, &rDataView, &currentDataBase, command, useTmp);
 
      StopProgressBar(hProgressBar);
 
      if (nbRows >= 0)
        {
          QueryBar_Update(L"", currentCommand);
          RecordExecutedAction(TEXT(LOG_TEXTRUNSQL), NULL, currentCommand, NULL);
 
          SetWindowSubclass(hMainDataView, DataView_Procedure, SUBCLASS_TABLE_ID, 0);
 
          originalCommand = _wcsdup(currentCommand);
 
          SetVisibility(0, SHOW, 0);
          StatusBar_Update((nbRows != INT32_MAX) ? L"" : NULL, nbRows);
        }
      else
        {
          QueryBar_Update(sqlError, currentCommand);
          RecordExecutedAction(TEXT(LOG_TEXTRUNSQL), NULL, currentCommand, sqlError);
 
          NullFree(currentCommand);
 
          DataView_Close(hwnd);
        }
 
      InvalidateRect(hwnd, NULL, TRUE);
      UpdateWindow(hwnd);
 
      ShowWindow(hMainDataView, SW_SHOWNA);
 
      free(command);
    }
 
  return nbRows;
}
 

int64_t CreateCSVFromView(HWND hwnd)
{
  int64_t nbRows = -1;
 
  static exportation_table_type options;
 
  int okExport = DialogBoxParam((HINSTANCE)GetWindowInstance(hwnd), L"DialogExport", hwnd,
                                (DLGPROC)(void *)ProcedureExport, (LPARAM) &options);
 
  SetForegroundWindow(hwnd);
 
  if (okExport)
    {
      wchar_t *fileName = FileOutChooserWithInit(L"Exporter vers un fichier CSV ...", hwnd,
                          L"Fichier CSV (*.csv)\0*.csv\0", currentSelectedTable, TRUE);
 
      if (fileName)
        {
          FILE *fileOut = _wfopen(fileName, L"wt");
 
          if (fileOut)
            {
              char *separator = (char *)&options.separateur;
              char *quote = (char *)&options.delimiteur;
 
              HANDLE hProgressBar = StartProgressBar(L"Enregistrement des donn\351es", -1);
              ExportDataToCSV(currentDataBase, currentCommand, separator, quote, fileOut);
              StopProgressBar(hProgressBar);
 
              fclose(fileOut);
            }
 
          free(fileName);
        }
    }
 
  return nbRows;
}
 

int RecordImportedFile(const wchar_t *tableName, const wchar_t *fileName, int pathLevel)
{
  int result = -1;
 
  if (tableName && tableName[0] && fileName && fileName[0])
    {
      // Ouvre le fichier
 
      HANDLE hFile = CreateFile(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
 
      if (hFile != INVALID_HANDLE_VALUE)
        {
          // Obtient les caractéristiques du fichier
 
          BY_HANDLE_FILE_INFORMATION fileInfo;
 
          if (GetFileInformationByHandle(hFile, &fileInfo))
            {
              // récupération du chemin sur le niveau ad hoc
 
              wchar_t path[MAX_BUF] = L"";
              wchar_t *pathPtr = path;
 
              if (pathLevel)
                {
                  int level = abs(pathLevel);
 
                  swprintf(path, sizeof(path) / sizeof(path[0]), L"%ls", fileName);
                  pathPtr = wcsrchr(path, L'\\');
                  while (pathPtr && level)
                    {
                      level --;
                      pathPtr[0] = L'\0';
                      pathPtr = wcsrchr(path, L'\\');
                    }
                }
 
              // récupération de la date et heure actuelle
 
              wchar_t nowDate[sizeof("YYYY-MM-DD")] = L"";
              wchar_t nowTime[sizeof("HH:MM:SS")] = L"";
 
              time_t dateTime = time(NULL);
 
              wcsftime(nowDate, sizeof(nowDate) / sizeof(wchar_t), L"%Y-%m-%d", localtime(&dateTime));
              wcsftime(nowTime, sizeof(nowTime) / sizeof(wchar_t), L"%H:%M:%S", localtime(&dateTime));
 
              // récupération de la date et heure du fichier
 
              SYSTEMTIME systemTime;
              FileTimeToSystemTime(&fileInfo.ftLastWriteTime, &systemTime);
 
              wchar_t *wRecord = calloc(MAX_BUF, sizeof(wchar_t));
 
              if (wRecord)
                {
                  swprintf(wRecord, MAX_BUF,
                           L"INSERT INTO " APP_FILES L" VALUES ("
                           L"'%ls',"
                           L"'%ls'," L"'%ls',"
                           L"'%ls'," L"'%ls',"
                           L"%lld,"
                           L"'%04d-%02d-%02d',"
                           L"'%02d:%02d:%02d'"
                           L")",
                           tableName,
                           nowDate, nowTime,
                           pathPtr ? &pathPtr[1] : L"", GetFileName(fileName),
                           fileInfo.nFileSizeLow + ((LONGLONG)fileInfo.nFileSizeHigh << 32),
                           systemTime.wYear, systemTime.wMonth, systemTime.wDay,
                           systemTime.wHour, systemTime.wMinute, systemTime.wSecond);
 
                  // enregistre les informations
 
                  result = RequestInDB(currentDataBase, wRecord);
 
                  free(wRecord);
                }
            }
 
 
          // Ferme le fichier
 
          CloseHandle(hFile);
        }
    }
 
  return result;
}
 

int RecordExecutedAction(const wchar_t *action, const wchar_t *dotCommand, const wchar_t *query, const wchar_t *error)
{
  int result = -1;
 
  if (action && action[0])
    {
      // récupération de la date et heure actuelle
 
      wchar_t nowDate[sizeof("YYYY-MM-DD")] = L"";
      wchar_t nowTime[sizeof("HH:MM:SS")] = L"";
 
      time_t dateTime = time(NULL);
 
      wcsftime(nowDate, sizeof(nowDate) / sizeof(wchar_t), L"%Y-%m-%d", localtime(&dateTime));
      wcsftime(nowTime, sizeof(nowTime) / sizeof(wchar_t), L"%H:%M:%S", localtime(&dateTime));
 
      wchar_t *wRecord = calloc(MAX_BUF, sizeof(wchar_t));
 
      if (wRecord)
        {
          wchar_t *mAction = (wchar_t *)action;
          WReplaceInStringNoFree(&mAction, L"'", L"''");
 
          wchar_t *mDotCommand = (wchar_t *)dotCommand;
          WReplaceInStringNoFree(&mDotCommand, L"'", L"''");
 
          wchar_t *mQuery = (wchar_t *)query;
          WReplaceInStringNoFree(&mQuery, L"'", L"''");
 
          wchar_t *mError = (wchar_t *)error;
          WReplaceInStringNoFree(&mError, L"'", L"''");
 
          swprintf(wRecord, MAX_BUF,
                   L"INSERT INTO " APP_HISTORY L" VALUES ("
                   L"'%ls'," L"'%ls',"
                   L"'%ls',"
                   L"'%ls',"
                   L"'%ls',"
                   L"'%ls'"
                   L")",
                   nowDate, nowTime,
                   mAction ? mAction : L"",
                   mDotCommand ? mDotCommand : L"",
                   mQuery ? mQuery : L"",
                   mError ? mError : L"");
 
          if (mAction != action)
            {
              free(mAction);
            }
 
          if (mDotCommand != dotCommand)
            {
              free(mDotCommand);
            }
 
          if (mQuery != query)
            {
              free(mQuery);
            }
 
          if (mError != error)
            {
              free(mError);
            }
 
          // enregistre les informations
 
          result = RequestInDB(currentDataBase, wRecord);
 
          free(wRecord);
        }
    }
 
  return result;
}
 

int64_t CreateTableFromCSV(HWND hwnd)
{
  int64_t nbRows = -1;
 
  wchar_t *fileName = FileInChooser(L"Importer des donn\351es CSV ...", hwnd,
                                    L"Fichier d\351limit\351 (*.csv;*.tsv;*.del;*.txt)\0*.csv;*.tsv;*.del;*.txt\0"
                                    L"Tout fichier (*.*)\0*.*\0");
 
  if (fileName)
    {
      HANDLE hPB = StartProgressBar(L"Test du fichier ...", -1);
      int type = typefil(fileName, FIL_TAB_DEL);
      StopProgressBar(hPB);
 
      if (type & FIL_ERR)
        {
          MessageBox(hwnd, L"\n Probl\350me de fichier ! \n", L"Erreur !", MB_ICONINFORMATION);
        }
 
 
      else if (!(type & FIL_TAB))
        {
          MessageBox(hwnd,
                     L"\n Ce fichier n'est pas reconnu comme une table par " SOFT_NAMEW L" ! \n",
                     L"Erreur !",
                     MB_ICONINFORMATION);
        }
 
      else
        {
          BOOL resultat = 1;
 
          if (type & FIL_NON & FIL_TAB_DEL)
            {
              if (!DialogBoxParam((HINSTANCE)GetWindowInstance(hwnd),
                                  L"DialogDELTableStructure", hwnd,
                                  (DLGPROC)(void *)ProcedureDELTableStructure,
                                  (LPARAM)fileName))
                {
                  resultat = 0;
                }
 
              SetForegroundWindow(hwnd);
            }
 
 
          if (resultat)
            {
              TAB *table = fileopen_TAB(fileName, type);
 
              if (table)
                {
                  hPB = StartProgressBar(L"Import des donn\351es CSV ...", -1);
                  wchar_t *tableName = _wcsdup(GetStrictFileName(fileName));
 
                  if (tableName)
                    {
                      wchar_t *query = calloc(MAX_BUF, sizeof(wchar_t));
 
                      if (query)
                        {
                          // création de la table avec les champs identifiés et typés (option texte à prévoir ?)
 
                          for (UINT column = 0; column < table->nb_champs; ++ column)
                            {
                              const wchar_t *fieldType = DATA_TEXT;
 
                              if (table->champ[column].type == L'D')
                                {
                                  fieldType = DATA_DATETIME;
                                }
 
                              if (table->champ[column].type == L'N')
                                {
                                  if (table->champ[column].decimales == 0)
                                    {
                                      fieldType = DATA_INTEGER;
                                    }
                                  else
                                    {
                                      fieldType = DATA_REAL;
                                    }
                                }
 
                              wchar_t *fieldName = _wcsdup(table->champ[column].nom);
 
                              if (fieldName)
                                {
                                  WReplaceInString(&fieldName, L"'", L"''");
 
                                  swprintf(query, MAX_BUF, L"%ls TABLE \"%ls\" %ls \"%ls\" %ls %ls",
                                           column ? L"ALTER" : L"CREATE",
                                           tableName,
                                           column ? L"ADD" : L"(",
                                           fieldName,
                                           fieldType,
                                           column ? L"" : L")"
                                          );
 
                                  RequestInDB(currentDataBase, query);
 
                                  free(fieldName);
                                }
                            }
 
                          // ajoute les enregistrements
 
                          nbRows = 0;
 
                          while (fileread_TAB(1, table) == 1)
                            {
                              if (!(nbRows % 1000))
                                {
                                  if (nbRows)
                                    {
                                      EndTransactionInDB(currentDataBase);
                                    }
 
                                  StartTransactionInDB(currentDataBase);
                                }
 
                              if (ProgressBarStopped())
                                {
                                  break;
                                }
 
                              nbRows ++;
 
                              wchar_t *ptr = table->reg;
 
                              AppendNewLine(currentDataBase, tableName, nbRows);
 
                              for (UINT column = 0; column < table->nb_champs; ++ column)
                                {
                                  const wchar_t *fieldName = table->champ[column].nom;
 
                                  wchar_t *value = wcsdup(&ptr[table->champ[column].pos]);
 
                                  if (value)
                                    {
                                      if (table->champ[column].type == L'N')
                                        {
                                          Replace(value, L',', L'.');
                                        }
 
                                      InsertValue(currentDataBase, tableName, nbRows, fieldName, value);
 
                                      free(value);
                                    }
                                }
 
                              SetProgressBarTextNum(L"Lignes import\351es", &nbRows);
                            }
 
                          if (nbRows)
                            {
                              EndTransactionInDB(currentDataBase);
                            }
 
                          free(query);
                        }
 
                      if (currentSelectedTable)
                        {
                          free(currentSelectedTable);
                        }
 
                      currentSelectedTable = tableName;
                      RecordImportedFile(tableName, fileName, 0);
                    }
 
                  fileclose_TAB(table);
 
                  SetProgressBarTextNumText(L"Lignes import\351es", &nbRows, L"Optimisation de la base");
                  RequestInDB(currentDataBase, L"ANALYSE;");
 
                  StopProgressBar(hPB);
                }
            }
        }
 
      free(fileName);
    }
 
  SetForegroundWindow(hwnd);
 
  return nbRows;
}
 

int64_t ProjectTree_ViewAppTable(HWND hwnd, int id)
{
  int64_t nbRows = -1;
 
  const wchar_t *command = L"";
 
  switch (id)
    {
      case APP_FILES_ID :
        {
          command = L"SELECT * FROM " APP_FILES;
          break;
        }
 
      case APP_HISTORY_ID :
        {
          command = L"SELECT * FROM " APP_HISTORY;
          break;
        }
 
      default :
        {
          break;
        }
    }
 
 
  NullFree(originalCommand);
  NullFree(currentCommand);
  currentCommand = _wcsdup(command);
 
  HANDLE hProgressBar = StartProgressBar(L"Lecture de la table", -1);
  nbRows = DataView_Update(hwnd, &hMainDataView, &rDataView, &currentDataBase, command, USE_TEMP_VIEW);
  StopProgressBar(hProgressBar);
 
  if (nbRows >= 0)
    {
      QueryBar_Update(L"", L"");
 
      SetWindowSubclass(hMainDataView, DataView_Procedure, SUBCLASS_TABLE_ID, 0);
 
      originalCommand = _wcsdup(command);
 
      SetVisibility(0, SHOW, 0);
      StatusBar_Update((nbRows != INT32_MAX) ? L"" : NULL, nbRows);
    }
  else
    {
      QueryBar_Update(TEXT(MESSAGE_INFO_FAILURE), L"");
 
      NullFree(currentCommand);
 
      DataView_Close(hwnd);
    }
 
  InvalidateRect(hwnd, NULL, TRUE);
  UpdateWindow(hwnd);
 
  ShowWindow(hMainDataView, SW_SHOWNA);
 
  return nbRows;
}
 

const wchar_t *GetCellValue(LVHITTESTINFO hti)
{
  const wchar_t *result = NULL;
 
  int64_t line = (dataViewPage * DATAVIEW_MAXROWS) + hti.iItem;
  int column = hti.iSubItem;
 
  if (column == 0)
    {
      static wchar_t number[INT_MAXSIZE + 1];
      swprintf(number, _countof(number), L"%lld", line + 1);
      result = number;
    }
  else if (column > 0)
    {
      result = ReadInTableFromSQLiteDB(currentDataBase,
                                       L"SELECT * FROM \"" APP_VIEWTABLE L"\"",
                                       line, column - 1, 0);
    }
 
  return result;
}
 

int ProjectTree_RenameTable(HWND hwnd, const wchar_t *oldTableName, const wchar_t *newTableName)
{
  int result = 0;
 
  freezeDataView = TRUE;
 
  HTREEITEM hSelectedTableItem = TreeView_GetSelection(hMainProjectTree);
 
  if (hSelectedTableItem)
    {
      TV_ITEM item = {0};
      item.mask = TVIF_PARAM;
      item.hItem = hSelectedTableItem;
 
      if ((TreeView_GetItem(hMainProjectTree, &item) == TRUE)
          && ((item.lParam == PROJECTTREE_TABLE) || (item.lParam == PROJECTTREE_APPTABLE)))
        {
          if (_wcsicmp(oldTableName, newTableName))
            {
              int renameTable = MessageBox(hwnd, TEXT(MESSAGE_QUESTION_RENAMETABLE),
                                           TEXT(MESSAGE_TITLE_WARNING), MB_YESNO | MB_ICONQUESTION);
 
              if (renameTable == IDYES)
                {
                  int length = MAX_BUF;
                  wchar_t *query = calloc(length, sizeof(wchar_t));
 
                  if (query)
                    {
                      swprintf(query, length, L"ALTER TABLE \"%ls\" RENAME TO \"%ls\"", oldTableName, newTableName);
                      int okRename = RequestInDBwithError(currentDataBase, query, &sqlError);
 
                      RecordExecutedAction(TEXT(LOG_TEXTRENAMETABLE), NULL, query, (okRename == SQLITE_OK) ? NULL : sqlError);
 
                      QueryBar_Update(L"", L"");
                      DataView_Close(hwnd);
                      ProjectTree_Update(hwnd);
 
                      free(query);
                    }
                }
            }
        }
    }
 
  freezeDataView = FALSE;
 
  return result;
}
 

int ProjectTree_DeleteTable(HWND hwnd)
{
  int result = 0;
 
  freezeDataView = TRUE;
 
  HTREEITEM hSelectedTableItem = TreeView_GetSelection(hMainProjectTree);
 
  if (hSelectedTableItem)
    {
      wchar_t *tableName = calloc(MIN_BUF, sizeof(wchar_t));
 
      if (tableName)
        {
          TV_ITEM item = {0};
 
          item.mask = TVIF_TEXT | TVIF_PARAM;
          item.pszText = tableName;
          item.cchTextMax = MIN_BUF;
          item.hItem = hSelectedTableItem;
 
          if ((TreeView_GetItem(hMainProjectTree, &item) == TRUE)
              && ((item.lParam == PROJECTTREE_TABLE) || (item.lParam == PROJECTTREE_APPTABLE)))
            {
              int deleteTable = MessageBox(hwnd, TEXT(MESSAGE_QUESTION_DROPTABLE),
                                           TEXT(MESSAGE_TITLE_WARNING), MB_YESNO | MB_ICONQUESTION);
 
              if (deleteTable == IDYES)
                {
                  int length = MAX_BUF;
                  wchar_t *query = calloc(length, sizeof(wchar_t));
 
                  if (query)
                    {
                      swprintf(query, length, L"DROP TABLE \"%ls\"", tableName);
                      int okDelete = RequestInDBwithError(currentDataBase, query, &sqlError);
 
                      RecordExecutedAction(TEXT(LOG_TEXTDELETETABLE), NULL, query,
                                           (okDelete == SQLITE_OK) ? NULL : sqlError);
 
                      if (okDelete != SQLITE_OK)
                        {
                          swprintf(query, length, L"DROP VIEW \"%ls\"", tableName);
                          okDelete = RequestInDBwithError(currentDataBase, query, &sqlError);
 
                          RecordExecutedAction(TEXT(LOG_TEXTDELETETABLE), NULL, query,
                                               (okDelete == SQLITE_OK) ? NULL : sqlError);
                        }
 
                      QueryBar_Update(L"", L"");
                      DataView_Close(hwnd);
                      ProjectTree_Update(hwnd);
 
                      free(query);
                    }
                }
            }
 
          free(tableName);
        }
    }
 
  freezeDataView = FALSE;
 
  return result;
}
 

void Main_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
  switch (id)
    {
      case IDM_HELP :
        {
          RunHelp(hwnd);
          break;
        }
 
      case IDM_ABOUT :
        {
          ShowAboutBox(hwnd);
          break;
        }
 
      case IDM_OPTIONS :
        {
          DialogBox((HINSTANCE)GetWindowInstance(hwnd), L"DialogOptions", hwnd, (DLGPROC)(void *)Options_Procedure);
          break;
        }
 
      case IDM_PAGE_PREVIOUS :
        {
          if (dataViewPage > 0)
            {
              -- dataViewPage;
 
              int64_t remainingRows = dataViewNbRows - (dataViewPage * DATAVIEW_MAXROWS);
              ListView_SetItemCountEx(hMainDataView, (remainingRows > DATAVIEW_MAXROWS) ? DATAVIEW_MAXROWS : remainingRows,
                                      LVSICF_NOINVALIDATEALL | LVSICF_NOSCROLL);
            }
          break;
        }
 
      case IDM_PAGE_NEXT :
        {
          if (dataViewPage < 40)
            {
              ++ dataViewPage;
 
              int64_t remainingRows = dataViewNbRows - (dataViewPage * DATAVIEW_MAXROWS);
 
              if (remainingRows < 0)
                {
                  -- dataViewPage;
                }
              else
                {
                  ListView_SetItemCountEx(hMainDataView, (remainingRows > DATAVIEW_MAXROWS) ? DATAVIEW_MAXROWS : remainingRows,
                                          LVSICF_NOINVALIDATEALL | LVSICF_NOSCROLL);
                }
            }
          break;
        }
 
      case IDM_DATA_COPYVALUE:
        {
          const wchar_t *text = GetCellValue(selectedCellInfo);
 
          if (text)
            {
              CopyInClipBoard(hwnd, text);
            }
 
          break;
        }
 
      case IDM_PROJECT_CONVERT :
        {
          if (MessageBox(hwnd, TEXT(CONVERT_PROJECT), L"", MB_OKCANCEL) == IDOK)
            {
              ProjectTree_Open(hwnd, id);
            }
 
          PostMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDM_PROJECT_OPTIMIZE, 0), 0);
          break;
        }
 
      case IDM_INIT :
      case IDM_PROJECT_NEW :
      case IDM_PROJECT_OPEN :
        {
          ProjectTree_Open(hwnd, id);
          break;
        }
 
      case IDM_DATA_IMPORT :
        {
          CreateTableFromCSV(hwnd);
          ProjectTree_Update(hwnd);
          ProjectTree_SelectTableByName(currentSelectedTable);
          break;
        }
 
      case IDM_DATA_EXPORT :
        {
          CreateCSVFromView(hwnd);
          break;
        }
 
      case IDM_TABLE_EXPORT :
      case IDM_TABLE_RENAME :
        {
          HTREEITEM hSelectedTableItem = TreeView_GetSelection(hMainProjectTree);
 
          if (hSelectedTableItem)
            {
              TV_ITEM item = {0};
              item.mask = TVIF_PARAM;
              item.hItem = hSelectedTableItem;
 
              if ((TreeView_GetItem(hMainProjectTree, &item) == TRUE)
                  && ((item.lParam == PROJECTTREE_TABLE) || (item.lParam == PROJECTTREE_APPTABLE)))
                {
                  if (id == IDM_TABLE_RENAME)
                    {
                      SetFocus(hMainProjectTree);
                      TreeView_EditLabel(hMainProjectTree, hSelectedTableItem);
                    }
                  else if (id == IDM_TABLE_EXPORT)
                    {
                      ProjectTree_ViewSelectedTable(hwnd, hSelectedTableItem);
                      CreateCSVFromView(hwnd);
                    }
                }
            }
 
          break;
        }
 
      case IDM_TABLE_DELETE :
        {
          ProjectTree_DeleteTable(hwnd);
          break;
        }
 
      case IDM_DATA_CLOSE :
        {
          DataView_Close(hwnd);
          ProjectTree_Update(hwnd);
          break;
        }
 
      case IDM_PROJECT_UPDATE :
        {
          ProjectTree_Update(hwnd);
          break;
        }
 
      case IDM_PROJECT_OPTIMIZE :
        {
          HANDLE hPb = StartProgressBar(L"Optimisation en cours ...", -2);
          RequestInDB(currentDataBase, L"ANALYSE;");
          StopProgressBar(hPb);
          break;
        }
 
      case IDM_PROJECT_LOG_IMPORT :
        {
          ProjectTree_ViewAppTable(hwnd, APP_FILES_ID);
          break;
        }
 
      case IDM_PROJECT_LOG_COMMAND :
        {
          ProjectTree_ViewAppTable(hwnd, APP_HISTORY_ID);
          break;
        }
 
      case IDM_SQL_FILE :
        {
          ExecuteSQLScript(hwnd, NULL);
          ProjectTree_Update(hwnd);
          break;
        }
 
      case IDM_SQL_QUERY :
        {
          ExecuteCustomSQLQuery(hwnd);
          ProjectTree_Update(hwnd);
          break;
        }
 
      case IDM_PROJECT_CLOSE :
        {
          ProjectTree_Close(hwnd);
          break;
        }
 
      default :
        {
          Main_OnExtraCommand(hwnd, id, hwndCtl, codeNotify);
          break;
        }
    }
}
 

void Main_OnContextMenu(HWND hwnd, HWND hwndContext, short int xPos, short int yPos)
{
  HMENU hMenu = NULL;
 
  freezeDataView = TRUE;
 
  POINT pt = {xPos, yPos};
  ScreenToClient(hwndContext, &pt);
 
  if (hwndContext == hMainDataView)
    {
      ZeroMemory(&selectedCellInfo, sizeof(selectedCellInfo));
      selectedCellInfo.pt = pt;
 
      ListView_SubItemHitTest(hwndContext, &selectedCellInfo);
 
      hMenu = LoadMenu((HINSTANCE)GetWindowInstance(hwnd), L"ViewMenu");
    }
  else if (hwndContext == hMainProjectTree)
    {
      TVHITTESTINFO tvhti = {0};
      tvhti.pt = pt;
 
      TreeView_HitTest(hwndContext, &tvhti);
 
      if (tvhti.flags & TVHT_ONITEM)
        {
          TV_ITEM item = {0};
 
          item.mask = TVIF_PARAM;
          item.hItem = tvhti.hItem;
 
          if ((TreeView_GetItem(hMainProjectTree, &item) == TRUE)
              && ((item.lParam == PROJECTTREE_TABLE) || (item.lParam == PROJECTTREE_APPTABLE)))
            {
              // avant d'éditer, récupère la sélection courante
              hActualSelectedTableItem = TreeView_GetSelection(hMainProjectTree);
 
              TreeView_SelectItem(hwndContext, tvhti.hItem);
              hMenu = LoadMenu((HINSTANCE)GetWindowInstance(hwnd), L"TreeMenu");
            }
        }
    }
 
  if (hMenu)
    {
      static HMENU hPopMenu = NULL;
      hPopMenu = GetSubMenu(hMenu, 0);
 
      TrackPopupMenuEx(hPopMenu, 0, xPos, yPos, hwnd, NULL);
      DestroyMenu(hMenu);
    }
 
  freezeDataView = FALSE;
}
 

void ProjectTree_ViewSelectedTable(HWND hwnd, HTREEITEM hItem)
{
  QueryBar_Update(L"", L"");
  DataView_Close(hwnd);
 
  if (hItem)
    {
      TV_ITEM item;
 
      wchar_t *tableName = calloc(MIN_BUF, sizeof(wchar_t));
 
      if (tableName)
        {
          if (currentSelectedTable)
            {
              free(currentSelectedTable);
            }
 
          currentSelectedTable = tableName;
 
          item.mask = TVIF_TEXT | TVIF_PARAM;
          item.lParam = 0;
          item.pszText = tableName;
          item.cchTextMax = MIN_BUF;
          item.hItem = hItem;
 
          if ((TreeView_GetItem(hMainProjectTree, &item) == TRUE)
              && ((item.lParam == PROJECTTREE_TABLE) || (item.lParam == PROJECTTREE_APPTABLE)))
            {
              size_t length = wcslen(tableName) + sizeof("SELECT * FROM \"\"");
              wchar_t *command = calloc(length, sizeof(wchar_t));
 
              if (command)
                {
                  swprintf(command, length, L"SELECT * FROM \"%ls\"", tableName);
 
                  NullFree(originalCommand);
                  NullFree(currentCommand);
                  currentCommand = command;
 
                  int nbRows = DataView_Update(hwnd, &hMainDataView, &rDataView, &currentDataBase, command, USE_TEMP_VIEW | ACTUAL_TABLE);
 
                  QueryBar_Update(sqlError, currentCommand);
 
                  if (nbRows >= 0)
                    {
                      SetWindowSubclass(hMainDataView, DataView_Procedure, SUBCLASS_TABLE_ID, 0);
 
                      originalCommand = _wcsdup(command);
 
                      SetVisibility(0, SHOW, 0);
                      StatusBar_Update((nbRows != INT32_MAX) ? tableName : NULL, nbRows);
                    }
                  else
                    {
                      currentCommand = NULL;
                      free(command);
                    }
                }
            }
        }
    }
}
 

int Main_OnNotify_DrawDataView(HWND hwnd, LPNMLVCUSTOMDRAW lplvcd)
{
  static int clrText;
  static int clrTextBk;
 
  switch (lplvcd->nmcd.dwDrawStage)
    {
      case CDDS_PREPAINT :
        {
          return CDRF_NOTIFYITEMDRAW;
        }
 
      case CDDS_ITEMPREPAINT :
        {
          clrText = lplvcd->clrText;
          clrTextBk = lplvcd->clrTextBk;
 
          return CDRF_NOTIFYSUBITEMDRAW;
        }
 
      case CDDS_SUBITEM | CDDS_ITEMPREPAINT :
        {
          /*(lplvcd->iSubItem == 3)*/ // cible le numéro de colonne
          /*(lplvcd->nmcd.dwItemSpec == 2)*/ // cible le numéro de ligne
          /*(lplvcd->nmcd.lItemlParam == <valeur perso>)*/ // cible le paramètre optionnel de l'item (ligne)
 
          switch (lplvcd->iSubItem)
            {
              case 0 :
                {
                  if (!mainFixedBlackFont)
                    {
                      UINT dpi = GetWindowDpi(hwnd);
                      mainFixedBlackFont = CreateFontForDPI(FIXED_FONT, FW_BLACK, SIZE_OF_FONT, dpi);
                    }
 
                  if (mainFixedBlackFont)
                    {
                      SelectObject(lplvcd->nmcd.hdc, mainFixedBlackFont);
                    }
 
                  lplvcd->clrText = clrText;
                  lplvcd->clrTextBk = GetSysColor(COLOR_BTNFACE);
 
                  break;
                }
 
              default :
                {
                  if (!mainFixedFont)
                    {
                      UINT dpi = GetWindowDpi(hwnd);
                      mainFixedFont = CreateFontForDPI(FIXED_FONT, FW_THIN, SIZE_OF_FONT, dpi);
                    }
 
                  if (mainFixedFont)
                    {
                      SelectObject(lplvcd->nmcd.hdc, mainFixedFont);
                    }
 
                  lplvcd->clrText = clrText;
                  lplvcd->clrTextBk = clrTextBk;
 
                  break;
                }
            }
 
          return CDRF_NEWFONT;
        }
 
      default :
        {
          return CDRF_DODEFAULT;
        }
    }
}
 

void Main_OnNotify_ApplyFilter(HWND hHeader)
{
  if (hHeader && currentCommand)
    {
      int length = wcslen(originalCommand) + MAX_BUF;
      wchar_t *query = calloc(length, sizeof(wchar_t));
 
      if (query)
        {
          dataViewPage = 0;
          dataViewNbRows = 0;
 
          swprintf(query, length, L"SELECT * FROM (%ls)", originalCommand);
 
          int nbColumns = Header_GetItemCount(hHeader);
 
          int testColumn = 0;
 
          for (int column = 1; column < nbColumns; ++ column)
            {
              wchar_t columnFilter[MIN_BUF] = {0};
              wchar_t columnName[MIN_BUF] = {0};
 
              HD_ITEM hdi = {0};
              HD_TEXTFILTER htf = {0};
 
              hdi.mask = HDI_FILTER | HDI_TEXT;
 
              hdi.pszText = columnName;
              hdi.cchTextMax = _countof(columnName) - 1;
 
              hdi.type = HDFT_ISSTRING;
              //hdi.type = HDFT_ISNUMBER;
              //hdi.type = HDFT_ISDATE;
              hdi.pvFilter = &htf;
 
              htf.pszText = columnFilter;
              htf.cchTextMax = _countof(columnFilter) - 1;
 
              Header_GetItem(hHeader, column, &hdi);
 
              if (columnFilter[0])
                {
                  swprintf(&query[wcslen(query)], length - wcslen(query),
                           L" %ls \"%ls\" LIKE '%ls'",
                           (!testColumn) ? L"WHERE" : L"AND", columnName, columnFilter);
 
                  ++ testColumn;
                }
            }
 
          SetWindowRedraw(hMainDataView, FALSE);
          ListView_DeleteAllItems(hMainDataView);
 
          currentCommand = query;
 
          int nbRows = FillAListView_Win32(hMainDataView, currentDataBase, currentDataBaseName, query, &sqlError, USE_TEMP_TABLE, NULL);
 
          QueryBar_Update(sqlError, currentCommand);
 
          if (nbRows >= 0)
            {
              StatusBar_Update((nbRows != INT32_MAX) ? L"" : NULL, nbRows);
              dataViewNbRows = nbRows;
            }
          else
            {
              NullFree(currentCommand);
              currentCommand = originalCommand;
            }
 
          SetVisibility(0, SHOW, 0);
 
          SetWindowRedraw(hMainDataView, TRUE);
        }
    }
}
 

void RestartScrollingTimer(HWND hwnd)
{
  if (scrollingTimer)
    {
      KillTimer(hwnd, scrollingTimer);
    }
 
  scrollingTimer = SetTimer(hwnd, SCROLL_TIMER_ID, SCROLL_IDLE_MS, NULL);
}
 

int Main_OnNotify_FillDataView(LPNMLVDISPINFOW lplvdi)
{
  int result = FALSE;
 
  if (lplvdi->item.mask & LVIF_TEXT)
    {
      int64_t line = (dataViewPage * DATAVIEW_MAXROWS) + lplvdi->item.iItem;
      int column = lplvdi->item.iSubItem;
 
      result = TRUE;
 
      if ((!scrollingTimer || !column) && (line >= 0))
        {
          static wchar_t *text;
 
          if (column == 0)
            {
              static wchar_t number[INT_MAXSIZE + 1];
              swprintf(number, _countof(number), L"%lld", line + 1);
              text = number;
            }
          else if (column > 0)
            {
              text = ReadInTableFromSQLiteDB(currentDataBase, L"SELECT * FROM \"" APP_VIEWTABLE L"\"", line, column - 1, 0);
            }
          else
            {
              text = NULL;
            }
 
          // la chaîne copiée ne doit pas dépasser la longueur maximale acceptable (NUL final inclus)
 
          if (lplvdi->item.cchTextMax && text && (wcslen(text) >= (size_t)lplvdi->item.cchTextMax))
            {
              text[lplvdi->item.cchTextMax - 1] = L'\0';
            }
 
          lplvdi->item.pszText = text ? text : L"";
 
          // redimensionnement de la colonne
          if (1)
            {
              int textWidth = EstimateTextWidthWithFont(hMainDataView, text, mainFixedFont);
              int columnWidth = ListView_GetColumnWidth(hMainDataView, column);
 
              const int padding = 16;
              if (textWidth + padding > columnWidth)
                {
                  ListView_SetColumnWidth(hMainDataView, column, textWidth + padding);
                  InvalidateRect(hMainDataView, NULL, TRUE);
                }
            }
        }
      else
        {
          lplvdi->item.pszText = L"\267\267\267";
        }
    }
 
  return result;
}
 

BOOL Main_OnNotify(HWND hwnd,
                   int idCtrl __attribute__((unused)),
                   LPNMHDR pnmh)
{
  int result = FALSE;
 
  static wchar_t oldItemText[MIN_BUF];
 
  switch (pnmh->code)
    {
      // message de sélection d'un item du ProjectView
 
      case TVN_SELCHANGED :
        {
          if (pnmh->hwndFrom == hMainProjectTree)
            {
              if (!freezeDataView)
                {
                  HTREEITEM hItem = TreeView_GetSelection(hMainProjectTree);
                  ProjectTree_ViewSelectedTable(hwnd, hItem);
                }
            }
 
          break;
        }
 
 
      case TVN_BEGINLABELEDIT :
        {
          if (pnmh->hwndFrom == hMainProjectTree)
            {
              LPNMTVDISPINFO pdi = (LPNMTVDISPINFO)pnmh;
              swprintf(oldItemText, MIN_BUF, L"%ls", (pdi->item.pszText) ? pdi->item.pszText : L"");
            }
 
          break;
        }
 
      case TVN_ENDLABELEDIT :
        {
          if (pnmh->hwndFrom == hMainProjectTree)
            {
              LPNMTVDISPINFO pdi = (LPNMTVDISPINFO)pnmh;
 
              if (pdi->item.pszText)
                {
                  TV_ITEM tvi = {0};
 
                  tvi.mask = TVIF_TEXT;
                  tvi.hItem = pdi->item.hItem;
                  tvi.pszText = pdi->item.pszText;
 
                  TreeView_SetItem(hMainProjectTree, &tvi);
 
                  ProjectTree_RenameTable(hwnd, oldItemText, pdi->item.pszText);
                }
            }
 
          break;
        }
 
 
      // gère l'aspect et la mise en forme du ListView (polices, couleurs, ...)
 
      case NM_CUSTOMDRAW :
        {
          if (pnmh->hwndFrom == hMainDataView)
            {
              LPNMLVCUSTOMDRAW lplvcd = (LPNMLVCUSTOMDRAW)pnmh;
              result = Main_OnNotify_DrawDataView(hwnd, lplvcd);
            }
 
          break;
        }
 
 
      case LVN_BEGINSCROLL:
      case LVN_ENDSCROLL:
        {
          if (pnmh->hwndFrom == hMainDataView)
            {
              RestartScrollingTimer(hwnd);
            }
 
          break;
        }
 
 
      // message indiquant la partie de la table à placer en cache
 
      case LVN_ODCACHEHINT :
        {
          if ((pnmh->hwndFrom == hMainDataView) && !scrollingTimer)
            {
              LPNMLVCACHEHINT lplvch = (LPNMLVCACHEHINT)pnmh;
 
              int64_t line = (dataViewPage * DATAVIEW_MAXROWS) + lplvch->iFrom;
              int number = (lplvch->iTo - lplvch->iFrom) + 1;
 
              ReadInTableFromSQLiteDB(currentDataBase, L"SELECT * FROM \"" APP_VIEWTABLE L"\"", line, 0, number);
            }
 
          break;
        }
 
 
      // alimente le DataView en données à la demande
 
      case LVN_GETDISPINFO :
        {
          if (pnmh->hwndFrom == hMainDataView)
            {
              LPNMLVDISPINFOW lplvdi = (LPNMLVDISPINFOW)pnmh;
              result = Main_OnNotify_FillDataView(lplvdi);
            }
 
          break;
        }
 
 
      // gère la recherche d'un item particulier
 
      case LVN_ODFINDITEM :
        {
          return -1;
        }
 
 
      // gère une demande de filtrage sur clic du bouton de filtre
 
      case HDN_FILTERBTNCLICK :
        {
          LPNMHDFILTERBTNCLICK lphdfi = (LPNMHDFILTERBTNCLICK)pnmh;
 
          HWND hHeader = lphdfi->hdr.hwndFrom;
          Main_OnNotify_ApplyFilter(hHeader);
 
          break;
        }
 
 
      // gère une demande de filtrage automatique
 
      case HDN_FILTERCHANGE :
        {
          /*LPNMHEADER lphead = (LPNMHEADER)pnmh;
 
          HWND hHeader = pnmh->hwndFrom;
          Main_OnNotify_ApplyFilter(hHeader);*/
 
          break;
        }
 
 
      case LVN_COLUMNCLICK :
        {
          HWND hListView = pnmh->hwndFrom;
          LPNMLISTVIEW pnmv = (LPNMLISTVIEW)pnmh;
 
          int numColumn = pnmv->iSubItem;
          ListView_SetSelectedColumn(hListView, numColumn);
 
          break;
        }
 
 
      default :
        {
          break;
        }
    }
 
  return result;
}
 

LRESULT CALLBACK Main_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  switch (uMsg)
    {
        HANDLE_MSG(hwnd, WM_CREATE, Main_OnCreate);
        HANDLE_MSG(hwnd, WM_CLOSE, Main_OnClose);
        HANDLE_MSG(hwnd, WM_DESTROY, Main_OnClose);
        HANDLE_MSG(hwnd, WM_PAINT, Main_OnPaint);
        HANDLE_MSG(hwnd, WM_SIZE, Main_OnSize);
        HANDLE_MSG(hwnd, WM_COMMAND, Main_OnCommand);
        HANDLE_MSG(hwnd, WM_CONTEXTMENU, Main_OnContextMenu);
        HANDLE_MSG(hwnd, WM_NOTIFY, Main_OnNotify);
 
      case WM_ERASEBKGND :
        {
          HDC hdc = (HDC)wParam;
 
          RECT rect;
 
          if (!hMainProjectTree)
            {
              GetClientRect(hwnd, &rect);
              FillRect(hdc, &rect, GetSysColorBrush(COLOR_BTNFACE));
            }
          else if (!hMainDataView)
            {
              FillRect(hdc, &rDataView, GetSysColorBrush(COLOR_BTNFACE));
            }
 
          return TRUE;
        }
 
      case WM_TIMER :
        {
          // temporisation du relâchement de la barre de scroll
          // celle-ci peut être vue à tort comme relachée, un tempo permet de gérer
          if (wParam == SCROLL_TIMER_ID)
            {
              KillTimer(hwnd, SCROLL_TIMER_ID);
              scrollingTimer = 0;
 
              InvalidateRect(hMainDataView, NULL, TRUE);
              UpdateWindow(hMainDataView);
            }
 
          if (wParam == NBROWS_TIMER_ID)
            {
              int64_t nbRows = VerifierTermine(NULL);
 
              if (nbRows != -1)
                {
                  KillTimer(hwnd, NBROWS_TIMER_ID);
                  dataViewNbRows = nbRows;
                  ListView_SetItemCountEx(hMainDataView, (nbRows > DATAVIEW_MAXROWS) ? DATAVIEW_MAXROWS : nbRows,
                                          LVSICF_NOINVALIDATEALL | LVSICF_NOSCROLL);
                  StatusBar_Update((nbRows != INT32_MAX) ? L"" : NULL, nbRows);
                }
            }
 
          break;
        }
 
      default :
        {
          return DefWindowProc(hwnd, uMsg, wParam, lParam);
        }
    }
 
  return FALSE;
}
 

LRESULT CALLBACK ProjectTree_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
                                       UINT_PTR uIdSubclass, DWORD_PTR dwRefData __attribute__((unused)))
{
  switch (uMsg)
    {
      case WM_WINDOWPOSCHANGING :
        {
          RestartScrollingTimer(GetParent(hwnd));
 
          WINDOWPOS *wp = (LPWINDOWPOS) lParam;
 
          if (!(wp->flags & (SWP_NOSIZE/* | SWP_NOMOVE*/)))
            {
              rProjectTree.left = wp->x;
              rProjectTree.top = wp->y;
              rProjectTree.right = wp->x + wp->cx;
              rProjectTree.bottom = wp->y + wp->cy;
 
              RECT r;
              GetClientRect(GetParent(hwnd), &r);
 
              RECT rSB;
              GetClientRect(hMainStatusBar, &rSB);
 
              int bottom = r.bottom - rSB.bottom;
 
              if (wp->x > 0)
                {
                  wp->cx += wp->x;
                  wp->x = 0;
                }
 
              if (wp->y > 0)
                {
                  wp->cy += wp->y;
                  wp->y = 0;
                }
 
              if (wp->cy > (bottom - BUTTON_SIZE))
                {
                  wp->cy = bottom - BUTTON_SIZE;
                }
 
              xTableView = wp->cx;
              SetWindowPos(hMainDataView, 0, wp->cx, 0, r.right - wp->cx, wp->cy, SWP_NOSENDCHANGING);
 
              rDataView.left = wp->cx;
              rDataView.top = 0;
              rDataView.right = r.right;
              rDataView.bottom = wp->cy;
 
              SetWindowPos(hMainQueryError, 0, 0, wp->cy, xQueryEdit, bottom - wp->cy, SWP_NOSENDCHANGING);
              SetWindowPos(hMainQueryEdit, 0, xQueryEdit, wp->cy, (r.right - BUTTON_SIZE) - xQueryEdit, bottom - wp->cy, SWP_NOSENDCHANGING);
              SetWindowPos(hMainQueryExecute, 0, (r.right - BUTTON_SIZE), wp->cy, BUTTON_SIZE, bottom - wp->cy, SWP_NOSENDCHANGING);
 
              return 0;
            }
 
          break;
        }
 
      case WM_NCDESTROY:
        {
          RemoveWindowSubclass(hwnd, ProjectTree_Procedure, uIdSubclass);
          break;
        }
 
      default :
        {
          break;
        }
    }
 
  return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}
 

LRESULT CALLBACK DataView_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
                                    UINT_PTR uIdSubclass, DWORD_PTR dwRefData __attribute__((unused)))
{
  switch (uMsg)
    {
      case WM_WINDOWPOSCHANGING :
        {
          RestartScrollingTimer(GetParent(hwnd));
 
          WINDOWPOS *wp = (LPWINDOWPOS) lParam;
 
          if (!(wp->flags & (SWP_NOSIZE/* | SWP_NOMOVE*/)))
            {
              rDataView.left = wp->x;
              rDataView.top = wp->y;
              rDataView.right = wp->x + wp->cx;
              rDataView.bottom = wp->y + wp->cy;
 
              RECT rParent;
              GetClientRect(GetParent(hwnd), &rParent);
 
              RECT rSB;
              GetClientRect(hMainStatusBar, &rSB);
 
              int bottom = rParent.bottom - rSB.bottom;
 
              if ((wp->x + wp->cx) < rParent.right)
                {
                  wp->cx = rParent.right - wp->x;
                }
 
              if (wp->y > 0)
                {
                  wp->cy += wp->y;
                  wp->y = 0;
                }
 
              if (wp->cy > (bottom - BUTTON_SIZE))
                {
                  wp->cy = bottom - BUTTON_SIZE;
                }
 
              xTableView = wp->x;
              SetWindowPos(hMainProjectTree, 0, 0, 0, wp->x, wp->cy, SWP_NOSENDCHANGING);
 
              rProjectTree.left = 0;
              rProjectTree.top = 0;
              rProjectTree.right = wp->cx;
              rProjectTree.bottom = wp->cy;
 
              SetWindowPos(hMainQueryEdit, 0, xQueryEdit, wp->cy, (rParent.right - BUTTON_SIZE) - xQueryEdit, bottom - wp->cy, SWP_NOSENDCHANGING);
              SetWindowPos(hMainQueryError, 0, 0, wp->cy, xQueryEdit, bottom - wp->cy, SWP_NOSENDCHANGING);
              SetWindowPos(hMainQueryExecute, 0, (rParent.right - BUTTON_SIZE), wp->cy, BUTTON_SIZE, bottom - wp->cy, SWP_NOSENDCHANGING);
 
              return 0;
            }
 
          break;
        }
 
      case WM_NCDESTROY:
        {
          RemoveWindowSubclass(hwnd, DataView_Procedure, uIdSubclass);
          break;
        }
 
      default :
        {
          break;
        }
    }
 
  return DefSubclassProc(hwnd, uMsg, wParam, lParam);
}
 

int64_t DataView_Update(HWND hwnd, HWND * pListView, RECT * rListView, sqlite3 **db, const wchar_t *command, int useTmp)
{
  int64_t nbRows = -1;
 
  dataViewPage = 0;
  dataViewNbRows = 0;
 
  if (db && command && command[0])
    {
      // Ouverture ou création de la base SQLite courante si besoin
 
      int result = SQLITE_OK;
 
      if (!db[0])
        {
          result = OpenSQLiteDB(db, currentDataBaseName, FALSE);
        }
 
      if (result == SQLITE_OK)
        {
          // Destruction du ListView précédent
 
          if (pListView[0])
            {
              DestroyWindow(pListView[0]);
            }
 
          // crée un nouveau ListView
 
          int virtualListView = (useTmp & USE_NO_TEMP) ? 0 : LVS_OWNERDATA;
          int listView_styles = LVS_REPORT/* | LVS_NOSORTHEADER*/;
          int window_styles = WS_CHILD | WS_THICKFRAME | WS_CLIPSIBLINGS;
 
          // c'est le WS_THICKFRAME qui pose le petit problème de largeur de la dernière colonne et de hauteur de la dernière ligne
          // mais sans cette option, le ListView n'a plus de bordure de redimensionnement
 
          pListView[0] = CreateWindowEx(0, WC_LISTVIEW, L"",
                                        virtualListView | listView_styles | window_styles,
                                        0, 0, 0, 0, hwnd, 0, (HINSTANCE)GetWindowInstance(hwnd), NULL);
 
          HWND hListView = pListView[0];
 
          if (hListView)
            {
              ListView_SetExtendedListViewStyleEx(hListView,
                                                  LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_DOUBLEBUFFER
                                                  | /*LVS_EX_HEADERDRAGDROP | */LVS_EX_LABELTIP,
                                                  LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES | LVS_EX_DOUBLEBUFFER
                                                  | LVS_EX_HEADERDRAGDROP | LVS_EX_LABELTIP);
 
              //ApplyDarkMode(hListView, L"DarkMode_Explorer");
 
              SetWindowPos(hListView,
                           HWND_TOP,
                           rListView->left,
                           rListView->top,
                           rListView->right - rListView->left,
                           rListView->bottom - rListView->top,
                           0);
 
              nbRows = FillAListView_Win32(hListView, db[0], currentDataBaseName, command, &sqlError, useTmp,
                                           (useTmp & USE_NO_TEMP) ? DataView_UpdateAll : DataView_UpdateHeader);
 
              if (nbRows < 0)
                {
                  // Destruction du ListView en cas d'échec
 
                  DestroyWindow(hListView);
                  pListView[0] = NULL;
                }
              else
                {
                  dataViewNbRows = nbRows;
                  if (!(useTmp & ACTUAL_TABLE) || (nbRows == INT32_MAX))
                    {
                      KillTimer(hwnd, NBROWS_TIMER_ID);
                      SetTimer(hwnd, NBROWS_TIMER_ID, NBROWS_IDLE_MS, NULL);
                    }
                }
            }
        }
    }
 
  return nbRows;
}
 

int64_t DataView_UpdateWithAFile(HWND hwnd, HWND * pListView, RECT * rListView, sqlite3 **db, wchar_t **command, const wchar_t *fileName)
{
  int64_t nbRows = -1;
  wchar_t *newFileName = NULL;
 
  if (db)
    {
      if (!fileName)
        {
          newFileName = FileInChooser(L"Lancer un script SQL", hwnd, L"Script SQL (*.sql)\0*.sql\0");
        }
 
      FILE *fileIn = OpenTextFileIn(SOFT_NAMEW, fileName ? fileName : newFileName);
 
      if (fileIn)
        {
          _fseeki64(fileIn, 0L, SEEK_END);
          _off64_t fileSize = _ftelli64(fileIn);
          _fseeki64(fileIn, 0L, SEEK_SET);
 
          wchar_t *sql = calloc(fileSize + 1, sizeof(wchar_t));
 
          if (sql)
            {
              fread(sql, sizeof(wchar_t), fileSize, fileIn);
 
              // Ouverture ou création de la base SQLite courante si besoin
 
              int result = SQLITE_OK;
 
              if (!db[0])
                {
                  wchar_t *projectName = calloc(FILENAMELENGTH_MAX, sizeof(wchar_t));
                  if (projectName)
                    {
                      LoadOption(SOFT_NAMEW, SOFT_NAMEW, OPTION_CURRENTPROJECT, projectName, FILENAMELENGTH_MAX);
                      result = OpenSQLiteDB(db, projectName, FALSE);
                      free(projectName);
                    }
                }
 
              if (result == SQLITE_OK)
                {
                  const wchar_t *lastSql = ScriptInDBwithAnswer(db[0], sql);
 
                  if (command && lastSql && lastSql[0])
                    {
                      NullFree(command[0]);
                      command[0] = _wcsdup(lastSql);
                      nbRows = DataView_Update(hwnd, pListView, rListView, db, lastSql, USE_NO_TEMP);
                    }
                }
 
              free(sql);
            }
 
          fclose(fileIn);
        }
    }
 
  if (newFileName)
    {
      free(newFileName);
    }
 
  return nbRows;
}
 

LRESULT CALLBACK Options_Procedure(HWND hwnd,
                                   UINT uMsg,
                                   WPARAM wParam,
                                   LPARAM lParam __attribute__((unused)))
{
  static HFONT hFont;
 
  switch (uMsg)
    {
      case WM_INITDIALOG :
        {
 
 
          RecreateDialogFont(hwnd, &hFont, VARIABLE_FONT, SIZE_OF_FONT);
 
          return TRUE;
        }
 
      case WM_COMMAND :
        {
          switch (LOWORD(wParam))
            {
              case IDOK :
                {
                  EndDialog(hwnd, 1);
 
                  if (hFont)
                    {
                      DeleteObject(hFont);
                      hFont = NULL;
                    }
 
                  return TRUE;
                }
 
              case IDCANCEL :
                {
                  EndDialog(hwnd, 0);
 
                  if (hFont)
                    {
                      DeleteObject(hFont);
                      hFont = NULL;
                    }
 
                  return TRUE;
                }
 
              default :
                {
                  return TRUE;
                }
            }
          break;
        }
 
      default :
        {
          break;
        }
    }
 
  return FALSE;
}