Référence du fichier TaupieGUI.c

implémentation des interfaces de Taupie Plus de détails...

#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"

Graphe des dépendances par inclusion de TaupieGUI.c:

Aller au code source de ce fichier.

Macros
#define	SCROLL_TIMER_ID   1
#define	SCROLL_IDLE_MS   100
#define	NBROWS_TIMER_ID   2
#define	NBROWS_IDLE_MS   1000
#define	DATAVIEW_MAXROWS   100000000

Fonctions
void	SetVisibility (int project, int table, int query)
	définit la visibilité des trois composants de l'écran.
int	ProjectTree_SelectTableByName (const wchar_t *tableName)
	Recherche et sélectionne dans l'arbre du projet une table identifiée par son nom. Limite la recherche à la racine de l'arbre et aux tables (ou vues).
int64_t	ProjectTree_Update (HWND hwnd)
	Crée un TreeView à partir du contenu de la base courante, et l'affiche aux bonnes dimensions.
void	StatusBar_Update (const wchar_t *tableName, int64_t records)
	Définit le contenu de la barre de statut principale.
void	Clean (void)
	Supprime les fichiers temporaires de l'application.
void	Main_OnPaint (HWND hwnd)
	redessine la boîte de dialogue.
void	Main_OnSize (HWND hwnd, UINT state, UINT x, UINT y)
	Gestion d'un changement de taille de la fenêtre principale.
void	QueryBar_Update (const wchar_t *errorMsg, const wchar_t *request)
	Définit le contenu de la QueryBar.
LRESULT CALLBACK	QueryExecute_Procedure (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
	sous-procédure spécifique du bouton de lancement de la requête.
LRESULT CALLBACK	QueryEdit_Procedure (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
	sous-procédure spécifique de la fenêtre d'écriture de requête.
LRESULT CALLBACK	QueryError_Procedure (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
	sous-procédure spécifique de la fenêtre d'affichage de requête.
void	QueryBar_Create (HWND hwnd)
	Création de l'espace de saisie des requêtes.
BOOL	Main_OnCreate (HWND hwnd, LPCREATESTRUCT lpCreateStruct)
	Initialisation de la fenêtre principale.
void	Main_OnClose (HWND hwnd)
	Supprime les fichiers temporaires et ferme l'application.
void	ProjectTree_Enlarge (void)
	redimensionne en largeur le ProjectTree.
void	ProjectTree_Close (HWND hwnd)
	Ferme le projet courant Taupie.
void	ProjectTree_Open (HWND hwnd, int option)
	Ouvre/crée un projet Taupie.
void	DataView_Close (HWND hwnd)
	Ferme la table sélectionnée dans le ProjectTree.
int64_t	ExecuteSQLScript (HWND hwnd, const wchar_t *fileName)
	Exécute une requête demandée par l'utilisateur.
int64_t	ExecuteCustomSQLQuery (HWND hwnd)
	Exécute une requête demandée par l'utilisateur.
int64_t	CreateCSVFromView (HWND hwnd)
	Crée une table dans la base courante à partir d'un fichier CSV.
int	RecordImportedFile (const wchar_t *tableName, const wchar_t *fileName, int pathLevel)
	Enregistrement des caractéristiques d'un fichier importé comme table.
int	RecordExecutedAction (const wchar_t *action, const wchar_t *dotCommand, const wchar_t *query, const wchar_t *error)
	Enregistrement dans l'historique d'une action de l'utilisateur.
int64_t	CreateTableFromCSV (HWND hwnd)
	Crée une table dans la base courante à partir d'un fichier CSV.
int64_t	ProjectTree_ViewAppTable (HWND hwnd, int id)
	Affiche une table "système", non présente dans l'arbre du projet.
const wchar_t *	GetCellValue (LVHITTESTINFO hti)
	Fonction permettant de récupérer le texte d'une cellule sélectionnée.
int	ProjectTree_RenameTable (HWND hwnd, const wchar_t *oldTableName, const wchar_t *newTableName)
	Renomme une table dans l'arbre du projet.
int	ProjectTree_DeleteTable (HWND hwnd)
	Supprime une table dans l'arbre du projet.
void	Main_OnCommand (HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
	Gère les commandes de l'application.
void	Main_OnContextMenu (HWND hwnd, HWND hwndContext, short int xPos, short int yPos)
	Gestion du menu contextuel.
void	ProjectTree_ViewSelectedTable (HWND hwnd, HTREEITEM hItem)
	Gère la sélection d'une table dans l'arbre du projet.
int	Main_OnNotify_DrawDataView (HWND hwnd, LPNMLVCUSTOMDRAW lplvcd)
	Redessine sur demande le listview (police, couleur, fond).
void	Main_OnNotify_ApplyFilter (HWND hHeader)
	Application du filtre courant à la vue courante des données.
void	RestartScrollingTimer (HWND hwnd)
	Relance la temporisation du DataView.
int	Main_OnNotify_FillDataView (LPNMLVDISPINFOW lplvdi)
	remplissage des items du DataView à la demande.
BOOL	Main_OnNotify (HWND hwnd, int idCtrl, LPNMHDR pnmh)
	Gestion des notifications des composants de la fenêtre principale.
LRESULT CALLBACK	Main_Procedure (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	procédure de la fenêtre principale.
LRESULT CALLBACK	ProjectTree_Procedure (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
	sous-procédure spécifique de la vue du projet (TreeView).
LRESULT CALLBACK	DataView_Procedure (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
	sous-procédure spécifique de la vue des données (DataView).
int64_t	DataView_Update (HWND hwnd, HWND *pListView, RECT *rListView, sqlite3 **db, const wchar_t *command, int useTmp)
	Crée un ListView à partir d'une commande SQL, et l'affiche aux bonnes dimensions.
int64_t	DataView_UpdateWithAFile (HWND hwnd, HWND *pListView, RECT *rListView, sqlite3 **db, wchar_t **command, const wchar_t *fileName)
LRESULT CALLBACK	Options_Procedure (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
	procédure du dialogue des options de ModuleTicket.

Variables
static HWND	hMainDataView
static HWND	hMainProjectTree
static HWND	hMainStatusBar
static HWND	hMainQueryError
static HWND	hMainQueryEdit
static HWND	hMainQueryExecute
static RECT	rProjectTree
static RECT	rDataView
static UINT_PTR	scrollingTimer
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
static int	dataViewPage
static int64_t	dataViewNbRows

Description détaillée

implémentation des interfaces de Taupie

Auteur

Denis MARTIN

dmart.nosp@m.in@t.nosp@m.aupie.nosp@m..net

Définition dans le fichier TaupieGUI.c.

Documentation des macros

SCROLL_TIMER_ID

#define SCROLL_TIMER_ID   1

Définition à la ligne 71 du fichier TaupieGUI.c.

SCROLL_IDLE_MS

#define SCROLL_IDLE_MS   100

Définition à la ligne 72 du fichier TaupieGUI.c.

NBROWS_TIMER_ID

#define NBROWS_TIMER_ID   2

Définition à la ligne 75 du fichier TaupieGUI.c.

NBROWS_IDLE_MS

#define NBROWS_IDLE_MS   1000

Définition à la ligne 76 du fichier TaupieGUI.c.

DATAVIEW_MAXROWS

#define DATAVIEW_MAXROWS   100000000

Définition à la ligne 100 du fichier TaupieGUI.c.

Documentation des fonctions

SetVisibility()

void SetVisibility	(	int	project,
		int	table,
		int	query )

définit la visibilité des trois composants de l'écran.

Paramètres

project	: visibilité du ProjectView.
table	: visibilité de la TableView.
query	: visibilité de la QueryBar.

Définition à la ligne 113 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

ProjectTree_SelectTableByName()

int ProjectTree_SelectTableByName

(

const wchar_t *

tableName

)

Recherche et sélectionne dans l'arbre du projet une table identifiée par son nom. Limite la recherche à la racine de l'arbre et aux tables (ou vues).

Paramètres

tableName

: nom de la table à sélectionner.

Renvoie

0 si l'item est trouvé, -1 dans le cas contraire.

Définition à la ligne 158 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

ProjectTree_Update()

int64_t ProjectTree_Update

(

HWND

hwnd

)

Crée un TreeView à partir du contenu de la base courante, et l'affiche aux bonnes dimensions.

Paramètres

hwnd	: handle de la fenêtre principale.

Renvoie

le nombre d'items du projet, sinon -1.

Définition à la ligne 219 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

StatusBar_Update()

void StatusBar_Update	(	const wchar_t *	tableName,
		int64_t	records )

Définit le contenu de la barre de statut principale.

Paramètres

tableName	: nom de la table courante en UTF-16 (NULL : effacement).
records	: nombre d'enregistrements.

Définition à la ligne 271 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

Clean()

void Clean

(

void

)

Supprime les fichiers temporaires de l'application.

Définition à la ligne 293 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

Main_OnPaint()

void Main_OnPaint

(

HWND

hwnd

)

redessine la boîte de dialogue.

Cette fonction reçoit le message WM_PAINT et le traite.

Paramètres

hwnd	: handle de la fenêtre principale

Définition à la ligne 313 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

Main_OnSize()

void Main_OnSize	(	HWND	hwnd,
		UINT	state,
		UINT	x,
		UINT	y )

Gestion d'un changement de taille de la fenêtre principale.

Paramètres

hwnd	: handle de la fenêtre principale.
state	:
x	: largeur de la zone client de la fenêtre.
y	: hauteur de la zone client de la fenêtre.

Définition à la ligne 349 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

QueryBar_Update()

void QueryBar_Update	(	const wchar_t *	errorMsg,
		const wchar_t *	request )

Définit le contenu de la QueryBar.

Paramètres

errorMsg	: message d'erreur en UTF-8 (NULL pour ne pas modifier le contenu actuel)
request	: texte de la requête en UTF-16 (NULL pour ne pas modifier le contenu actuel)

Définition à la ligne 444 du fichier TaupieGUI.c.

{
  if (errorMsg)
    {
      SetWindowText(hMainQueryError, errorMsg);
    }
 
  if (request)
    {
      SetWindowText(hMainQueryEdit, request);
    }
}

Voici le graphe des appelants de cette fonction :

QueryExecute_Procedure()

LRESULT CALLBACK QueryExecute_Procedure	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		UINT_PTR	uIdSubclass,
		DWORD_PTR	dwRefData )

sous-procédure spécifique du bouton de lancement de la requête.

Paramètres

hwnd	: handle de la fenêtre.
uMsg	: message à traiter.
wParam	: premier paramètre du message.
lParam	: second paramètre du message.
uIdSubclass	: utilisé indirectement.
dwRefData	: non utilisé.

Définition à la ligne 469 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

QueryEdit_Procedure()

LRESULT CALLBACK QueryEdit_Procedure	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		UINT_PTR	uIdSubclass,
		DWORD_PTR	dwRefData )

sous-procédure spécifique de la fenêtre d'écriture de requête.

Paramètres

hwnd	: handle de la fenêtre.
uMsg	: message à traiter.
wParam	: premier paramètre du message.
lParam	: second paramètre du message.
uIdSubclass	: utilisé indirectement.
dwRefData	: non utilisé.

Définition à la ligne 517 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

QueryError_Procedure()

LRESULT CALLBACK QueryError_Procedure	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		UINT_PTR	uIdSubclass,
		DWORD_PTR	dwRefData )

sous-procédure spécifique de la fenêtre d'affichage de requête.

Paramètres

hwnd	: handle de la fenêtre.
uMsg	: message à traiter.
wParam	: premier paramètre du message.
lParam	: second paramètre du message.
uIdSubclass	: utilisé indirectement.
dwRefData	: non utilisé.

Définition à la ligne 599 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

QueryBar_Create()

void QueryBar_Create

(

HWND

hwnd

)

Création de l'espace de saisie des requêtes.

Paramètres

hwnd	: handle de la fenêtre principale.

Définition à la ligne 685 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

Main_OnCreate()

BOOL Main_OnCreate	(	HWND	hwnd,
		LPCREATESTRUCT	lpCreateStruct )

Initialisation de la fenêtre principale.

Cette fonction reçoit le message WM_CREATE et le traite.

Paramètres

hwnd	: handle de la fenêtre.
lpCreateStruct	: pointeur vers la structure des informations de création.

Renvoie

TRUE (donne le focus à la fenêtre).

Définition à la ligne 726 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

Main_OnClose()

void Main_OnClose

(

HWND

hwnd

)

Supprime les fichiers temporaires et ferme l'application.

Paramètres

hwnd	: handle de la fenêtre principale.

Définition à la ligne 797 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

ProjectTree_Enlarge()

void ProjectTree_Enlarge

(

void

)

redimensionne en largeur le ProjectTree.

Définition à la ligne 833 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

ProjectTree_Close()

void ProjectTree_Close

(

HWND

hwnd

)

Ferme le projet courant Taupie.

Paramètres

hwnd	: handle de la fenêtre principale.

Définition à la ligne 870 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

ProjectTree_Open()

void ProjectTree_Open	(	HWND	hwnd,
		int	option )

Ouvre/crée un projet Taupie.

Paramètres

hwnd	: handle de la fenêtre principale.
option	: définit s'il faut créer ou ouvrir le projet.

Définition à la ligne 920 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

DataView_Close()

void DataView_Close

(

HWND

hwnd

)

Ferme la table sélectionnée dans le ProjectTree.

Paramètres

hwnd	: handle de la fenêtre principale.

Définition à la ligne 1049 du fichier TaupieGUI.c.

{
  SetVisibility(0, HIDE, 0);
  StatusBar_Update(NULL, 0);
 
  if (hMainDataView)
    {
      DestroyWindow(hMainDataView);
      hMainDataView = NULL;
    }
}

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

ExecuteSQLScript()

int64_t ExecuteSQLScript	(	HWND	hwnd,
		const wchar_t *	fileName )

Exécute une requête demandée par l'utilisateur.

Paramètres

hwnd	: handle de la fenêtre principale.
fileName	: nom complet du fichier contenant la requête à exécuter (peut être NULL).

Renvoie

le nombre de lignes produites en retour de la requête ou -1 en cas d'erreur.

Définition à la ligne 1071 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

ExecuteCustomSQLQuery()

int64_t ExecuteCustomSQLQuery

(

HWND

hwnd

)

Exécute une requête demandée par l'utilisateur.

Paramètres

hwnd	: handle de la fenêtre principale.

Renvoie

le nombre de lignes produites en retour de la requête ou -1 en cas d'erreur.

Définition à la ligne 1125 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

CreateCSVFromView()

int64_t CreateCSVFromView

(

HWND

hwnd

)

Crée une table dans la base courante à partir d'un fichier CSV.

Paramètres

hwnd	: handle de la fenêtre principale.

Renvoie

le nombre d'enregistrements du fichier généré ou -1 en cas d'erreur.

Définition à la ligne 1189 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

RecordImportedFile()

int RecordImportedFile	(	const wchar_t *	tableName,
		const wchar_t *	fileName,
		int	pathLevel )

Enregistrement des caractéristiques d'un fichier importé comme table.

Paramètres

tableName	: nom de la table créée.
fileName	: nom absolu du fichier à enregistrer.
pathLevel	: niveau de chemin à enregistrer (0 : aucun).

Renvoie

0 si OK, valeur non nulle en cas de problème.

Définition à la ligne 1239 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

RecordExecutedAction()

int RecordExecutedAction	(	const wchar_t *	action,
		const wchar_t *	dotCommand,
		const wchar_t *	query,
		const wchar_t *	error )

Enregistrement dans l'historique d'une action de l'utilisateur.

Paramètres

action	: texte descriptif de l'action.
dotCommand	: texte de la dot command (SQLite) équivalente.
query	: texte de la requête SQL équivalente.
error	: commentaire éventuel d'erreur, souvent celui généré par SQLite.

Renvoie

0 si OK, valeur non nulle en cas de problème.

Définition à la ligne 1341 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

CreateTableFromCSV()

int64_t CreateTableFromCSV

(

HWND

hwnd

)

Crée une table dans la base courante à partir d'un fichier CSV.

La méthode de création n'est pas optimale en terme de vitesse, mais permet la concaténation de la table importée (B) avec celle présente (A) par ajout de champs et d'enregistrements sans préjuger des structures comparées des tables A et B.

Paramètres

hwnd	: handle de la fenêtre principale.

Renvoie

le nombre d'enregistrements de la table ou -1 en cas d'erreur.

Définition à la ligne 1431 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

ProjectTree_ViewAppTable()

int64_t ProjectTree_ViewAppTable	(	HWND	hwnd,
		int	id )

Affiche une table "système", non présente dans l'arbre du projet.

Paramètres

hwnd	: handle de la fenêtre principale.
id	: ID de la table à afficher.

Renvoie

le nombre de lignes affichées ou -1 en cas d'erreur.

Définition à la ligne 1630 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

GetCellValue()

const wchar_t * GetCellValue

(

LVHITTESTINFO

hti

)

Fonction permettant de récupérer le texte d'une cellule sélectionnée.

Paramètres

hti	: structure d'information sur l'item sélectionné.

Renvoie

Pointeur vers le texte alloué (à libérer avec free()).

NULL en cas d'erreur.

Définition à la ligne 1703 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

ProjectTree_RenameTable()

int ProjectTree_RenameTable	(	HWND	hwnd,
		const wchar_t *	oldTableName,
		const wchar_t *	newTableName )

Renomme une table dans l'arbre du projet.

Paramètres

hwnd	: handle de la fenêtre principale.
oldTableName	: ancien nom de la table.
newTableName	: nouveau nom de la table.

Renvoie

0 si OK, sinon valeur non nulle.

Définition à la ligne 1737 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

ProjectTree_DeleteTable()

int ProjectTree_DeleteTable

(

HWND

hwnd

)

Supprime une table dans l'arbre du projet.

Paramètres

hwnd	: handle de la fenêtre principale.

Renvoie

0 si OK, sinon valeur non nulle.

Définition à la ligne 1796 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

Main_OnCommand()

void Main_OnCommand	(	HWND	hwnd,
		int	id,
		HWND	hwndCtl,
		UINT	codeNotify )

Gère les commandes de l'application.

Paramètres

hwnd	: handle de la fenêtre principale.
id	: ID de la commande.
hwndCtl	: handle du contrôle.
codeNotify	: code défini par le contrôle.

Définition à la ligne 1873 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

Main_OnContextMenu()

void Main_OnContextMenu	(	HWND	hwnd,
		HWND	hwndContext,
		short int	xPos,
		short int	yPos )

Gestion du menu contextuel.

Paramètres

hwnd	: handle de la fenêtre principale.
hwndContext	: handle du composant.
xPos	: abscisse du clic.
yPos	: ordonnée du clic.

Définition à la ligne 2081 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

ProjectTree_ViewSelectedTable()

void ProjectTree_ViewSelectedTable	(	HWND	hwnd,
		HTREEITEM	hItem )

Gère la sélection d'une table dans l'arbre du projet.

Paramètres

hwnd	: handle de la fenêtre principale.
hItem	: handle de l'item sélectionné.

Définition à la ligne 2145 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

Main_OnNotify_DrawDataView()

int Main_OnNotify_DrawDataView	(	HWND	hwnd,
		LPNMLVCUSTOMDRAW	lplvcd )

Redessine sur demande le listview (police, couleur, fond).

Paramètres

hwnd	: handle de la fenêtre principale.
lplvcd	: pointeur sur la structure de dessin.

Renvoie

une macro qui dépend de ce qui est attendu.

Définition à la ligne 2219 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

Main_OnNotify_ApplyFilter()

void Main_OnNotify_ApplyFilter

(

HWND

hHeader

)

Application du filtre courant à la vue courante des données.

Paramètres

hHeader

: header de la vue courante (avec barre de filtre).

Définition à la ligne 2303 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

RestartScrollingTimer()

void RestartScrollingTimer

(

HWND

hwnd

)

Relance la temporisation du DataView.

Paramètres

hwnd	: handle de la fenêtre principale.

Définition à la ligne 2388 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

Main_OnNotify_FillDataView()

int Main_OnNotify_FillDataView

(

LPNMLVDISPINFOW

lplvdi

)

remplissage des items du DataView à la demande.

Paramètres

lplvdi

: .

Définition à la ligne 2405 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

Main_OnNotify()

BOOL Main_OnNotify	(	HWND	hwnd,
		int	idCtrl,
		LPNMHDR	pnmh )

Gestion des notifications des composants de la fenêtre principale.

Paramètres

hwnd	: handle de la fenêtre principale.
idCtrl	: identifiant du composant.
pnmh	: pointeur vers la structure du message.

Définition à la ligne 2476 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

Main_Procedure()

LRESULT CALLBACK Main_Procedure	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam )

procédure de la fenêtre principale.

Paramètres

hwnd	: handle de la fenêtre principale
uMsg	: message à traiter
wParam	: premier paramètre du message
lParam	: second paramètre du message

Définition à la ligne 2661 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

ProjectTree_Procedure()

LRESULT CALLBACK ProjectTree_Procedure	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		UINT_PTR	uIdSubclass,
		DWORD_PTR	dwRefData )

sous-procédure spécifique de la vue du projet (TreeView).

Paramètres

hwnd	: handle de la fenêtre.
uMsg	: message à traiter.
wParam	: premier paramètre du message.
lParam	: second paramètre du message.
uIdSubclass	: utilisé indirectement.
dwRefData	: non utilisé.

Définition à la ligne 2744 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

DataView_Procedure()

LRESULT CALLBACK DataView_Procedure	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		UINT_PTR	uIdSubclass,
		DWORD_PTR	dwRefData )

sous-procédure spécifique de la vue des données (DataView).

Paramètres

hwnd	: handle de la fenêtre.
uMsg	: message à traiter.
wParam	: premier paramètre du message.
lParam	: second paramètre du message.
uIdSubclass	: utilisé indirectement.
dwRefData	: non utilisé.

Définition à la ligne 2832 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

DataView_Update()

int64_t DataView_Update	(	HWND	hwnd,
		HWND *	pListView,
		RECT *	rListView,
		sqlite3 **	db,
		const wchar_t *	command,
		int	useTmp )

Crée un ListView à partir d'une commande SQL, et l'affiche aux bonnes dimensions.

Paramètres

hwnd	: handle de la fenêtre principale.
pListView	: pointeur vers le handle du listview.
rListView	: pointeur vers le rectangle prévu pour le listview (utile si le listview n'existe pas encore).
db	: vecteur vers la base de données SQLite à ouvrir.
command	: requête à exécuter.
useTmp	: indique s'il faut utiliser une table/vue temporaire ou une requête directe.

Renvoie

le nombre de lignes, sinon -1.

Définition à la ligne 2921 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

DataView_UpdateWithAFile()

int64_t DataView_UpdateWithAFile	(	HWND	hwnd,
		HWND *	pListView,
		RECT *	rListView,
		sqlite3 **	db,
		wchar_t **	command,
		const wchar_t *	fileName )

Définition à la ligne 3020 du fichier TaupieGUI.c.

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

Voici le graphe d'appel pour cette fonction :

Voici le graphe des appelants de cette fonction :

Options_Procedure()

LRESULT CALLBACK Options_Procedure	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam )

procédure du dialogue des options de ModuleTicket.

Paramètres

hwnd	: handle de la fenêtre principale.
uMsg	: message à traiter.
wParam	: premier paramètre du message.
lParam	: second paramètre du message.

Définition à la ligne 3098 du fichier TaupieGUI.c.

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

Voici le graphe des appelants de cette fonction :

Documentation des variables

hMainDataView

HWND hMainDataView

static

Définition à la ligne 60 du fichier TaupieGUI.c.

hMainProjectTree

HWND hMainProjectTree

static

Définition à la ligne 61 du fichier TaupieGUI.c.

hMainStatusBar

HWND hMainStatusBar

static

Définition à la ligne 62 du fichier TaupieGUI.c.

hMainQueryError

HWND hMainQueryError

static

Définition à la ligne 64 du fichier TaupieGUI.c.

hMainQueryEdit

HWND hMainQueryEdit

static

Définition à la ligne 65 du fichier TaupieGUI.c.

hMainQueryExecute

HWND hMainQueryExecute

static

Définition à la ligne 66 du fichier TaupieGUI.c.

rProjectTree

RECT rProjectTree

static

Définition à la ligne 68 du fichier TaupieGUI.c.

rDataView

RECT rDataView

static

Définition à la ligne 69 du fichier TaupieGUI.c.

scrollingTimer

UINT_PTR scrollingTimer

static

Définition à la ligne 73 du fichier TaupieGUI.c.

currentCommand

wchar_t* currentCommand

static

Définition à la ligne 79 du fichier TaupieGUI.c.

originalCommand

wchar_t* originalCommand

static

Définition à la ligne 80 du fichier TaupieGUI.c.

currentDataBase

sqlite3* currentDataBase

static

Définition à la ligne 82 du fichier TaupieGUI.c.

currentDataBaseName

wchar_t* currentDataBaseName

static

Définition à la ligne 83 du fichier TaupieGUI.c.

currentSelectedTable

wchar_t* currentSelectedTable

static

Définition à la ligne 84 du fichier TaupieGUI.c.

hActualSelectedTableItem

HTREEITEM hActualSelectedTableItem

static

Définition à la ligne 86 du fichier TaupieGUI.c.

selectedCellInfo

LVHITTESTINFO selectedCellInfo

static

Définition à la ligne 87 du fichier TaupieGUI.c.

mainVariableFont

HFONT mainVariableFont

static

Définition à la ligne 89 du fichier TaupieGUI.c.

mainFixedFont

HFONT mainFixedFont

static

Définition à la ligne 90 du fichier TaupieGUI.c.

mainFixedBlackFont

HFONT mainFixedBlackFont

static

Définition à la ligne 91 du fichier TaupieGUI.c.

xTableView

int xTableView

static

Définition à la ligne 93 du fichier TaupieGUI.c.

xQueryEdit

int xQueryEdit

static

Définition à la ligne 94 du fichier TaupieGUI.c.

sqlError

wchar_t* sqlError

static

Définition à la ligne 96 du fichier TaupieGUI.c.

freezeDataView

int freezeDataView

static

Définition à la ligne 98 du fichier TaupieGUI.c.

dataViewPage

int dataViewPage

static

Définition à la ligne 101 du fichier TaupieGUI.c.

dataViewNbRows

int64_t dataViewNbRows

static

Définition à la ligne 102 du fichier TaupieGUI.c.