Implémentation de la procédure de fenêtre et de l'interface. Plus de détails...

#include <stdio.h>
#include <locale.h>
#include <wchar.h>
#include <windows.h>
#include <commctrl.h>
#include "TaupieGUI.h"
#include "../_TkT2/Defines.h"
#include "resource.h"
#include "../_TkT2/EasyWin32.h"

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

Fonctions
static int	ProcessCommandLine (HWND hwnd, wchar_t *lpCmdLine)
	Traite les éventuels arguments passés au lancement de Taupie.
int WINAPI	wWinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nShowCmd)
	Procédure principale - point d'entrée du programme.

Description détaillée

Implémentation de la procédure de fenêtre et de l'interface.

Auteur: Denis MARTIN; dmart.nosp@m.in@t.nosp@m.aupie.nosp@m..net

Définition dans le fichier main.c.

Documentation des fonctions

◆ ProcessCommandLine()

int ProcessCommandLine	(	HWND	hwnd,
		wchar_t *	lpCmdLine )

static

Traite les éventuels arguments passés au lancement de Taupie.

Paramètres

hwnd	: handle de la fenêtre principale.
lpCmdLine	: paramètres de la ligne de commande.

Renvoie: indique le niveau de GUI à appliquer.

Définition à la ligne 135 du fichier main.c.

{
  int guiLevel = GUI_FULL;
 
  if (lpCmdLine && lpCmdLine[0])
    {
      int argc = 0;
      wchar_t **wArgv = CommandLineToArgvW(lpCmdLine, &argc);
 
      if (wArgv)
        {
          // convertit chaque argument de WideChar en UTF-8 pour pouvoir le traiter avec getopt
          // et les éventuels caractères intranscriptibles en ASCII Latin-1
 
          // ajoute aussi un premier argument vide car getopt passe toujours le premier argument !? (exécutable ?)
 
          // et ajoute un dernier argument NULL (théoriquement attendu par la norme)
 
          argc ++;
 
          char *argv[argc + 1];
 
          argv[0] = "";
 
          for (int index = 0; index < argc; index ++)
            {
              argv[index + 1] = NULL;
 
              if (wArgv[index])
                {
                  int length = WideCharToMultiByte(CP_UTF8, 0, wArgv[index], -1, NULL, 0, NULL, NULL);
 
                  if (length > 0)
                    {
                      argv[index + 1] = calloc(length, sizeof(char));
 
                      if (argv[index + 1])
                        {
                          WideCharToMultiByte(CP_UTF8, 0, wArgv[index], -1, argv[index + 1], length, NULL, NULL);
                        }
                    }
                }
            }
 
 
          // traitement des arguments par getopt
 
          BOOL p_openProject = FALSE;
          char *projectToOpen = NULL;
 
          BOOL i_GUI = FALSE;
 
          int option;
 
          /*
          *         Taupie peut être lancé avec des paramètres :
 
          *         -p projet à ouvrir (base SQLite3)
          *         Par exemple : Taupie -b "D:\MesFichiers\MonProjet.taupie"
 
                    -i mode interactif
 
          *         En mode silencieux, une option absente est à FALSE, alors qu'en mode interactif, une option absente
          *         est à sa valeur courante par défaut (telle qu'enregistrée dans les préférences).
          *         Dans tous les cas, les préférences sont mises à jour par l'exécution de la ligne de commande.
          */
 
          while ((option = getopt(argc, argv, ":p:i")) != -1)
            {
              opterr = 0;
 
              switch (option)
                {
                  case 'p' :
                    {
                      p_openProject = TRUE;
                      projectToOpen = optarg;
 
                      if (!i_GUI)
                        {
                          guiLevel = GUI_NOPE;
                        }
 
                      break;
                    }
 
 
                  case 'i' :
                    {
                      i_GUI = TRUE;
                      guiLevel = GUI_TEMP;
 
                      break;
                    }
 
                  case ':' : // argument manquant
                  case '?' : // option inconnue
                  default :
                    {
                      break;
                    }
                }
            }
 
 
          if (optind < argc)
            {
              p_openProject = TRUE;
              projectToOpen = argv[optind];
            }
 
 
          // traitement par Taupie des options et arguments identifiés
 
          if (p_openProject)
            {
              if (projectToOpen && projectToOpen[0])
                {
                  size_t length = strlen(projectToOpen) + 1;
                  wchar_t *wProjectToOpen = calloc(length, sizeof(wchar_t));
 
                  if (wProjectToOpen)
                    {
                      MultiByteToWideChar(CP_UTF8, 0, projectToOpen, -1, wProjectToOpen, length);
                      SaveOption(SOFT_NAMEW, SOFT_NAMEW, OPTION_CURRENTPROJECT, wProjectToOpen);
 
                      free(wProjectToOpen);
                    }
                }
 
              //PostMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDM_INIT, guiLevel), 0);
            }
 
 
          // libération de la mémoire
 
          LocalFree(wArgv);
 
          for (int index = 1; index <= argc; index ++)
            {
              if (argv[index])
                {
                  free(argv[index]);
                }
            }
        }
    }
 
  return guiLevel;
}

Voici le graphe des appelants de cette fonction :

◆ wWinMain()

int WINAPI wWinMain	(	HINSTANCE	hInstance,
		HINSTANCE	hPrevInstance,
		LPWSTR	lpCmdLine,
		int	nShowCmd )

Procédure principale - point d'entrée du programme.

Paramètres

hInstance	: instance du programme
hPrevInstance	: toujours NULL
lpCmdLine	: paramètres de la ligne de commande
nShowCmd	: affichage demandé

Renvoie: zéro si le programme se termine normalement; une valeur non nulle dans le cas contraire

Définition à la ligne 299 du fichier main.c.

{
  HANDLE hMutex = CreateMutex(NULL, FALSE, L"mutex " SOFT_NAMEW);
 
  if (GetLastError() == ERROR_ALREADY_EXISTS)
    {
      //MessageBox(NULL, SOFT_NAMEW L" est d\351j\340 ouvert ...", L"", MB_ICONINFORMATION | MB_SYSTEMMODAL);
 
      HWND hwnd = FindWindow(NULL, ABOUT_TEXTW);
      if (hwnd)
        {
          SetForegroundWindow(hwnd);
        }
 
      ReleaseMutex(hMutex);
      CloseHandle(hMutex);
 
      return 0;
    }
 
 
  _wsetlocale(LC_ALL, TEXT(SETLOCALE));
 
 
  // évite le plantage en cas d'utilisation de GetOpenFileName() ou de SHBrowseForFolder() sur le Bureau !!!
 
  OleInitialize(NULL); // appelle aussi CoInitializeEx avec le modèle thread adéquat
 
 
  WNDCLASSEX f_classe = {0};
 
  f_classe.hInstance = hInstance;
  f_classe.lpszClassName = L"mainWindowClass";
  f_classe.lpfnWndProc = Main_Procedure;
  f_classe.style = CS_HREDRAW | CS_VREDRAW;
  f_classe.cbSize = sizeof(WNDCLASSEX);
 
 
  f_classe.hIcon = LoadIcon(hInstance, L"mainIcon");
  f_classe.hIconSm = LoadIcon(hInstance, L"mainIcon");
  f_classe.hCursor = LoadCursor(NULL, IDC_ARROW);
  f_classe.lpszMenuName = L"MainMenu";
  f_classe.cbClsExtra = 0;
  f_classe.cbWndExtra = 0;
 
  // ne pas définir de fond par défaut :
  // -> évite le clignotement lors des redimensionnements internes
  // -> implique de dessiner soi-même les parties manquantes
 
  //f_classe.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
 
 
  if (!RegisterClassEx(&f_classe))
    {
      //DeleteObject(f_classe.hbrBackground);
      OleUninitialize();
 
      ReleaseMutex(hMutex);
      CloseHandle(hMutex);
 
      return 0;
    }
 
 
  HWND hwnd = CreateWindowEx(
                0,
                L"mainWindowClass",
                SOFT_NAMEW,
                WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS,
                CW_USEDEFAULT,
                CW_USEDEFAULT,
                CW_USEDEFAULT,
                CW_USEDEFAULT,
                HWND_DESKTOP,
                NULL,
                hInstance,
                NULL
              );
 
  ApplyDarkMode(hwnd, L"DarkMode_Explorer");
 
 
  int guiLevel = ProcessCommandLine(hwnd, lpCmdLine);
 
  switch (guiLevel)
    {
      case GUI_FULL :
        {
          ShowWindow(hwnd, SW_NORMAL);
          break;
        }
 
      case GUI_TEMP :
        {
          ShowWindow(hwnd, SW_HIDE);
          break;
        }
 
      case GUI_NOPE :
        {
          ShowWindow(hwnd, SW_HIDE);
          break;
        }
 
      default :
        {
          ShowWindow(hwnd, SW_NORMAL);
          break;
        }
    }
 
 
  // gestion des messages de la fenêtre principale
 
  MSG msg;
  ZeroMemory(&msg, sizeof(msg));
 
  while (TRUE)
    {
      if (msg.message == WM_QUIT)
        {
          break;
        }
 
      // ne pas utiliser PeekMessage(&msg,NULL,0,0,PM_REMOVE) car cela occupe le processeur en permanence !
      // il vaut mieux utiliser GetMessage(&msg,NULL,0,0) qui ne retourne que lorsqu'il y a un message et
      // laisse le processeur libre entre temps ...
      if (GetMessage(&msg, NULL, 0, 0) > 0)
        {
          TranslateMessage(&msg);
          DispatchMessage(&msg);
        }
    }
 
 
  //DeleteObject(f_classe.hbrBackground);
  OleUninitialize();
 
  ReleaseMutex(hMutex);
  CloseHandle(hMutex);
 
  return msg.wParam;
}

Voici le graphe d'appel pour cette fonction :

Fonctions

Description détaillée

Documentation des fonctions

◆ ProcessCommandLine()

◆ wWinMain()