PageRenderTime 93ms CodeModel.GetById 3ms app.highlight 73ms RepoModel.GetById 1ms app.codeStats 1ms

/thotlib/base/config.c

https://github.com/pffy/Amaya-Editor
C | 1908 lines | 1386 code | 130 blank | 392 comment | 481 complexity | f1896c0d033348eb0e7ea7b3e98c6d46 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1/*
   2 *
   3 *  (c) COPYRIGHT INRIA, 1996-2008
   4 *  Please first read the full copyright statement in file COPYRIGHT.
   5 *
   6 */
   7
   8/*
   9 * gestion des fichiers de configuration et de langue.
  10 *
  11 * Authors: V. Quint (IRNIA)
  12 *
  13 */
  14
  15#ifdef _WX
  16  #include "wx/wx.h"
  17#endif /* _WX */
  18
  19#include "thot_gui.h"
  20#include "thot_sys.h"
  21#include "constmedia.h"
  22#include "constmenu.h"
  23#include "typemedia.h"
  24#include "frame.h"
  25#include "language.h"
  26#include "application.h"
  27#include "appdialogue.h"
  28#include "fileaccess.h"
  29#include "document.h"
  30
  31#ifdef _WX
  32  #include "appdialogue_wx.h"
  33  #include "AmayaWindow.h"
  34#endif /* _WX */
  35
  36#ifdef _WINGUI
  37  #include "wininclude.h"
  38  int app_lang;
  39#endif /* _WINGUI */
  40
  41#undef THOT_EXPORT
  42#define THOT_EXPORT extern
  43#include "platform_tv.h"
  44#include "edit_tv.h"
  45#include "frame_tv.h"
  46#include "units_tv.h"
  47#include "appdialogue_tv.h"
  48
  49#define MAX_ITEM_CONF 100
  50
  51#include "applicationapi_f.h"
  52#include "fileaccess_f.h"
  53#include "inites_f.h"
  54#include "memory_f.h"
  55#include "message_f.h"
  56#include "thotmsg_f.h"
  57#include "views_f.h"
  58
  59static ThotBool     doc_import[MAX_ITEM_CONF];
  60static char        *doc_items[MAX_ITEM_CONF];
  61static char        *doc_items_menu[MAX_ITEM_CONF];
  62static char        *nat_items[MAX_ITEM_CONF];
  63static char        *nat_items_menu[MAX_ITEM_CONF];
  64static char        *ext_items[MAX_ITEM_CONF];
  65static char        *ext_items_menu[MAX_ITEM_CONF];
  66static char        *pres_items[MAX_ITEM_CONF];
  67static char        *pres_items_menu[MAX_ITEM_CONF];
  68static char        *export_items[MAX_ITEM_CONF];
  69static char        *export_items_menu[MAX_ITEM_CONF];
  70
  71/*----------------------------------------------------------------------
  72   ConfigInit initializes the configuration module
  73  ----------------------------------------------------------------------*/
  74void ConfigInit ()
  75{
  76  int                 i;
  77
  78  for (i = 0; i < MAX_ITEM_CONF; i++)
  79    {
  80      doc_items[i] = NULL;
  81      doc_import[i] = FALSE;
  82      doc_items_menu[i] = NULL;
  83      nat_items[i] = NULL;
  84      nat_items_menu[i] = NULL;
  85      ext_items[i] = NULL;
  86      ext_items_menu[i] = NULL;
  87      pres_items[i] = NULL;
  88      pres_items_menu[i] = NULL;
  89      export_items[i] = NULL;
  90      export_items_menu[i] = NULL;
  91    }
  92  /* TtaConfigReadConfigFiles (SchemaPath);*/
  93}
  94
  95/*----------------------------------------------------------------------
  96   getFirstWord                                                    
  97  ----------------------------------------------------------------------*/
  98static void getFirstWord (unsigned char *line, char *word)
  99{
 100   int             indword, indline;
 101
 102   indline = 0;
 103   word[0] = EOS;
 104   /* skip spaces if there are */
 105   while (line[indline] <= SPACE && line[indline] != EOS)
 106      indline++;
 107   if (line[indline] == '#')
 108      /* cette ligne ne comporte qu'un commentaire */
 109      return;
 110
 111   /* copie tous les caracteres jusqu'a rencontrer le 1er espace ou ":" */
 112   /* ou la fin de ligne */
 113   indword = 0;
 114
 115   while (line[indline] > SPACE && line[indline] != ':' &&
 116	  line[indline] != EOS)
 117         word[indword++] = line[indline++];
 118
 119   /* marque la fin du mot trouve' */
 120   word[indword] = EOS;
 121}
 122
 123
 124/*----------------------------------------------------------------------
 125   getSecondWord                                                   
 126  ----------------------------------------------------------------------*/
 127static void getSecondWord (unsigned char *line, char *word)
 128{
 129   int              indword, indline;
 130
 131   indline = 0;
 132   word[0] = EOS;
 133   /* saute les espaces de debut de ligne */
 134   while (line[indline] <= SPACE && line[indline] != EOS)
 135      indline++;
 136   if (line[indline] == '#')
 137      /* cette ligne ne comporte qu'un commentaire */
 138      return;
 139   /* saute le 1er mot, jusqu'a rencontrer le 1er espace */
 140   /* ou la fin de ligne */
 141   while (line[indline] > SPACE && line[indline] != EOS)
 142      indline++;
 143   /* saute les espaces qui suivent le 1er mot */
 144   while (line[indline] <= SPACE && line[indline] != EOS)
 145      indline++;
 146   if (line[indline] == '#')
 147      /* le premier mot est suivi d'un commentaire */
 148      return;
 149   /* copie tous les caracteres du 2eme mot jusqu'a rencontrer le 1er */
 150   /* espace ou la fin de ligne */
 151   indword = 0;
 152   while (line[indline] > SPACE && line[indline] != EOS)
 153      word[indword++] = line[indline++];
 154   /* marque la fin du mot trouve' */
 155   word[indword] = EOS;
 156}
 157
 158/*----------------------------------------------------------------------
 159   singleWord                                                      
 160  ----------------------------------------------------------------------*/
 161static ThotBool     singleWord (unsigned char *line)
 162{
 163  int                 ind;
 164
 165  ind = 0;
 166  /* saute les espaces de debut de ligne */
 167  while (line[ind] <= SPACE && line[ind] != EOS)
 168    ind++;
 169  if (line[ind] == '#')
 170    /* la ligne commence par un commentaire */
 171    return FALSE;
 172  /* saute le premier mot */
 173  while (line[ind] > SPACE && line[ind] != '#' && 
 174	 line[ind] != ':' && line[ind] != EOS)
 175    ind++;
 176  /* saute les espaces qui suivent le 1er mot */
 177  while (line[ind] <= SPACE && line[ind] != EOS)
 178    ind++;
 179  if (line[ind] == '#' || line[ind] == EOS)
 180    /* il ne reste rien dans la ligne ou seulement un commentaire */
 181    return TRUE;
 182  else
 183    /* il y a des caracteres significatifs apres le 1er mot */
 184    return FALSE;
 185}
 186
 187
 188/*----------------------------------------------------------------------
 189   getStringAfterColon                                             
 190  ----------------------------------------------------------------------*/
 191static void getStringAfterColon (unsigned char *line, char *text)
 192{
 193   int                 indline, indtext;
 194
 195   indline = 0;
 196   text[0] = EOS;
 197   while (line[indline] != ':' && line[indline] != EOS)
 198      indline++;
 199   if (line[indline] == ':')
 200     {
 201	indline++;
 202	while (line[indline] <= SPACE && line[indline] != EOS)
 203	   indline++;
 204	if (line[indline] == '#' || line[indline] == EOS)
 205	   return;
 206	indtext = 0;
 207	while (line[indline] != '#' && line[indline] != EOS)
 208	   text[indtext++] = line[indline++];
 209	/* elimine les blancs de fin de ligne */
 210	indtext--;
 211	while (text[indtext] <= SPACE && indtext >= 0)
 212	   indtext--;
 213	indtext++;
 214	/* termine la chaine */
 215	text[indtext] = EOS;
 216     }
 217}
 218
 219
 220/*----------------------------------------------------------------------
 221   readUntil       lit le fichier file (qui doit etre ouvert)      
 222   jusqu'a trouver une ligne qui contienne un seul mot,    
 223   soit word1 soit word2.                                  
 224   Retourne                                                
 225   0 si on ne trouve pas cette ligne,                   
 226   1 si on trouve le 1er mot,                           
 227   2 si on trouve le 2eme mot.                          
 228  ----------------------------------------------------------------------*/
 229static int readUntil (FILE *file, const char *word1, const char *word2)
 230{
 231   ThotBool            stop;
 232   int                 ret;
 233   char                line[MAX_TXT_LEN];
 234   char                word[MAX_TXT_LEN];
 235
 236   stop = FALSE;
 237   ret = 0;
 238   do
 239      if (fgets (line, MAX_TXT_LEN - 1, file) == NULL)
 240	 /* fin de fichier */
 241	 stop = TRUE;
 242      else
 243	{
 244	   getFirstWord ((unsigned char*)line, word);
 245	   if (singleWord ((unsigned char*)line))
 246	     {
 247		if (*word1 != EOS)
 248		   if (strcmp (word, word1) == 0)
 249		      ret = 1;
 250		if (*word2 != EOS)
 251		   if (strcmp (word, word2) == 0)
 252		      ret = 2;
 253	     }
 254	}
 255   while (!stop && ret == 0);
 256   return ret;
 257}
 258
 259#if 0
 260/*----------------------------------------------------------------------
 261   namesOfDocType                                                  
 262  ----------------------------------------------------------------------*/
 263static void namesOfDocType (char *fname, char **doctypeOrig,
 264			    char **doctypeTrans, int *typ, ThotBool *import)
 265{
 266   int                 i, l, point, res;
 267   FILE               *file;
 268   char                line[MAX_TXT_LEN];
 269   char                text[MAX_TXT_LEN];
 270   char                word[MAX_TXT_LEN];
 271   char                URL_DIR_SEP;
 272   ThotBool            stop;
 273
 274   *doctypeOrig = NULL;
 275   *doctypeTrans = NULL;
 276   *typ = CONFIG_UNKNOWN_TYPE;
 277   *import = FALSE;
 278
 279   if (fname && strchr (fname, '/'))
 280	  URL_DIR_SEP = '/';
 281   else 
 282	   URL_DIR_SEP = DIR_SEP;
 283
 284   /* ouvre le fichier */
 285   file = TtaReadOpen (fname);
 286   if (file == NULL)
 287     {
 288	fprintf (stderr, "cannot open file %s\n", fname);
 289	return;
 290     }
 291   /* cherche le premier mot du fichier, hors commentaires et espaces */
 292   stop = FALSE;
 293   do
 294      if (fgets (line, MAX_TXT_LEN - 1, file) == NULL)
 295	 stop = TRUE;
 296      else
 297	{
 298	   getFirstWord (line, word);
 299	   if (word[0] != EOS)
 300	      stop = TRUE;
 301	}
 302   while (!stop);
 303   if (!singleWord (line))
 304      /* le premier mot n'est pas seul dans la ligne, erreur */
 305      return;
 306
 307   if (strcmp (word, "document") == 0)
 308      *typ = CONFIG_DOCUMENT_STRUCT;
 309   else if (strcmp (word, "nature") == 0)
 310      *typ = CONFIG_NATURE_STRUCT;
 311   else if (strcmp (word, "extension") == 0)
 312      *typ = CONFIG_EXTENSION_STRUCT;
 313   else if (strcmp (word, "document-nature") == 0)
 314      *typ = CONFIG_EXCLUSION;
 315   else
 316      /* le premier mot du fichier est invalide */
 317     {
 318	fprintf (stderr, "file %s: invalid first word %s\n", fname, word);
 319	return;
 320     }
 321
 322   /* cherche le "." marquant le suffixe a la fin du nom de fichier */
 323   i = strlen (fname);
 324   while (i > 0 && fname[i] != '.')
 325      i--;
 326   if (fname[i] == '.')
 327      point = i;
 328   else
 329      point = 0;
 330   /* cherche le dernier DIR_SEP du nom de fichier */
 331   while (i > 0 && fname[i] != URL_DIR_SEP)
 332      i--;
 333   if (fname[i] == URL_DIR_SEP)
 334      i++;
 335   if (fname[i] == '_')
 336      /* ignore les fichiers dont le nom commence par "-" */
 337      return;
 338   l = strlen (&fname[i]) + 1;
 339   *doctypeOrig =	(char*) TtaGetMemory (l);
 340   if (point != 0)
 341      fname[point] = EOS;
 342   strcpy (*doctypeOrig, &fname[i]);
 343   /* retablit le '.' du suffixe dans le nom de fichier */
 344   if (point != 0)
 345      fname[point] = '.';
 346
 347   if (*typ == CONFIG_DOCUMENT_STRUCT || *typ == CONFIG_EXCLUSION)
 348      /* Il s'agit d'un type de document, on cherche une ligne */
 349      /* contenant un seul mot: "import" ou "translation" */
 350      res = readUntil (file, "import", "translation");
 351   else
 352      /* il s'agit d'une nature ou d'une extension, on ne cherche */
 353      /* que la ligne "translation" */
 354      res = readUntil (file, "", "translation");
 355   if (res == 1)
 356      /* on a trouve' le mot "import" */
 357     {
 358	*import = TRUE;
 359	/* cherche la ligne comportant le seul mot "translation" */
 360	res = readUntil (file, "", "translation");
 361     }
 362   if (res == 2)
 363      /* on a trouve' le mot translation */
 364     {
 365	/* on cherche la ligne qui donne la traduction du nom de schema */
 366	stop = FALSE;
 367	do
 368	   if (fgets (line, MAX_TXT_LEN - 1, file) == NULL)
 369	     {
 370		stop = TRUE;
 371		word[0] = EOS;
 372	     }
 373	   else
 374	     {
 375		getFirstWord (line, word);
 376		if (strcmp (word, *doctypeOrig) == 0)
 377		   stop = TRUE;
 378	     }
 379	while (!stop);
 380
 381	if (strcmp (word, *doctypeOrig) == 0)
 382	   /* on a trouve' la ligne voulue */
 383	  {
 384	     getStringAfterColon (line, text);
 385	     if (text[0] == EOS)
 386		fprintf (stderr, "invalid line in file %s\n   %s\n", fname, line);
 387	     else
 388	       {
 389		  *doctypeTrans = TtaGetMemory (strlen (text) + 1);
 390		  strcpy (*doctypeTrans, AsciiTranslate (text));
 391	       }
 392	  }
 393     }
 394   TtaReadClose (file);
 395
 396   /* Si le fichier de configuration ne definit pas de traduction pour */
 397   /* le nom du schema, on prend le nom d'origine comme traduction */
 398   if (*doctypeTrans == NULL)
 399     {
 400	*doctypeTrans = TtaGetMemory (l);
 401	strcpy (*doctypeTrans, *doctypeOrig);
 402     }
 403}
 404#endif
 405
 406/*----------------------------------------------------------------------
 407   ConfigFree
 408   Frees the table entries of all the document types, natures and
 409   extensions.
 410  ----------------------------------------------------------------------*/
 411void                ConfigFree (void)
 412{
 413   int i;
 414
 415   for (i = 0; i < MAX_ITEM_CONF; i++)
 416     {
 417	if (doc_items[i] != NULL)
 418	  {
 419	     TtaFreeMemory (doc_items[i]);
 420	     doc_items[i] = NULL;
 421	  }
 422	doc_import[i] = FALSE;
 423	if (doc_items_menu[i] != NULL)
 424	  {
 425	     TtaFreeMemory (doc_items_menu[i]);
 426	     doc_items_menu[i] = NULL;
 427	  }
 428	if (nat_items[i] != NULL)
 429	  {
 430	     TtaFreeMemory (nat_items[i]);
 431	     nat_items[i] = NULL;
 432	  }
 433	if (nat_items_menu[i] != NULL)
 434	  {
 435	     TtaFreeMemory (nat_items_menu[i]);
 436	     nat_items_menu[i] = NULL;
 437	  }
 438	if (ext_items[i] != NULL)
 439	  {
 440	     TtaFreeMemory (ext_items[i]);
 441	     ext_items[i] = NULL;
 442	  }
 443	if (ext_items_menu[i] != NULL)
 444	  {
 445	     TtaFreeMemory (ext_items_menu[i]);
 446	     ext_items_menu[i] = NULL;
 447	  }
 448     }
 449   }
 450#ifdef IV
 451/*----------------------------------------------------------------------
 452   TtaConfigReadConfigFiles (re)initialise les tables des schemas de
 453   structure (documents, natures et extensions) qui ont    
 454   des fichiers de langue dans les directories de schemas. 
 455  ----------------------------------------------------------------------*/
 456void TtaConfigReadConfigFiles (char *aSchemaPath)
 457{
 458  int                 nbitemdoc, nbitemnat, nbitemext;
 459  int                 beginning, i;
 460  int                 typ;
 461  ThotBool            import;
 462  char               *Dir;
 463  PathBuffer          DirBuffer;
 464#define NAME_LENGTH     100
 465#define MAX_NAME         80
 466#define SELECTOR_NB_ITEMS 5
 467  char               *suffix;
 468  PathBuffer          fname;
 469  char               *nameOrig;
 470  char               *nameTrans;
 471  ThotBool            stop;
 472
 473  /* force the english language in schemas */
 474  suffix = "en";
 475#ifdef _WINGUI
 476  app_lang = EN_LANG;
 477#endif /* _WINGUI */
 478  /* libere les anciennes entrees des tables de types de documents */
 479  /* de natures et d'extensions */
 480  ConfigFree ();
 481
 482  beginning = 0;
 483  i = 0;
 484  nbitemdoc = 0;
 485  nbitemnat = 0;
 486  nbitemext = 0;
 487  /* traite successivement tous les directories du path des schemas */
 488  strncpy (DirBuffer, aSchemaPath, MAX_PATH);
 489  stop = FALSE;
 490  while (DirBuffer[i] != EOS && i < MAX_PATH && !stop)
 491    {
 492      while (DirBuffer[i] != PATH_SEP && DirBuffer[i] != EOS && i < MAX_PATH)
 493	i++;
 494      if (DirBuffer[i] == EOS)
 495	/* dernier directory du path. Il faut s'arreter apres ce directory */
 496	stop = TRUE;
 497      if (DirBuffer[i] == PATH_SEP)
 498	DirBuffer[i] = EOS;
 499      if (DirBuffer[i] == EOS)
 500	/* un directory de schema a ete isole' */
 501	{
 502	  Dir = &DirBuffer[beginning];
 503	  if (TtaCheckDirectory (Dir))
 504	    /* c'est bien un directory */
 505	    {
 506	      /* commande "ls" sur le directory */
 507	    }
 508	  /* continue a chercher les directories dans le path des schemas */
 509	  i++;
 510	  beginning = i;
 511	}
 512    }
 513}
 514
 515/*----------------------------------------------------------------------
 516   ConfigMakeDocTypeMenu cree dans BufMenu la liste des schemas de 
 517   structure qui ont des fichiers de langue dans les       
 518   directories de schemas.                                 
 519   Si doc == TRUE on prend les schemas de documents, sinon 
 520   les schemas de nature.                                  
 521  ----------------------------------------------------------------------*/
 522int   ConfigMakeDocTypeMenu (char *BufMenu, int *lgmenu, ThotBool doc)
 523{
 524   int                 nbitem, len, i;
 525
 526   nbitem = 0;
 527   *lgmenu = 0;
 528   BufMenu[0] = EOS;
 529   i = 0;
 530
 531   if (doc)
 532      /* parcourt la table des noms de types de documents */
 533      while (i < MAX_ITEM_CONF && doc_items[i] != NULL)
 534	{
 535	   if (doc_items_menu[i] != NULL)
 536	      /* cette entree de la table a une traduction, on la prend */
 537	     {
 538		len = strlen (doc_items_menu[i]);
 539		strcpy (BufMenu + (*lgmenu), doc_items_menu[i]);
 540	     }
 541	   else
 542	      /* pas de traduction, on prend le nom d'origine du schema */
 543	     {
 544		len = strlen (doc_items[i]);
 545		strcpy (BufMenu + (*lgmenu), doc_items[i]);
 546	     }
 547	   (*lgmenu) += len + 1;
 548	   nbitem++;
 549	   i++;
 550	}
 551   else
 552      /* parcourt la table des noms de natures */
 553      while (i < MAX_ITEM_CONF && nat_items[i] != NULL)
 554	{
 555	   if (nat_items_menu[i] != NULL)
 556	      /* cette entree de la table a une traduction, on la prend */
 557	     {
 558		len = strlen (nat_items_menu[i]);
 559		strcpy (BufMenu + (*lgmenu), nat_items_menu[i]);
 560	     }
 561	   else
 562	      /* pas de traduction, on prend le nom d'origine du schema */
 563	     {
 564		len = strlen (nat_items[i]);
 565		strcpy (BufMenu + (*lgmenu), nat_items[i]);
 566	     }
 567	   (*lgmenu) += len + 1;
 568	   nbitem++;
 569	   i++;
 570	}
 571   return nbitem;
 572}
 573
 574
 575/*----------------------------------------------------------------------
 576   TtaConfigSSchemaExternalName retourne dans nameUser le nom     
 577   externe, dans la langue de l'utilisateur, du schema de          
 578   structure dont le nom interne est nameSchema.                    
 579   Typ indique s'il s'agit d'un schema de document (1), de         
 580   nature (2) ou d'extension (3).                                  
 581  ----------------------------------------------------------------------*/
 582void TtaConfigSSchemaExternalName (char *nameUser, char *nameSchema, int Typ)
 583{
 584   int                 i;
 585   ThotBool            found;
 586
 587   i = 0;
 588   found = FALSE;
 589   nameUser[0] = EOS;
 590   switch (Typ)
 591	 {
 592	    case CONFIG_DOCUMENT_STRUCT:
 593	       while (i < MAX_ITEM_CONF && !found && doc_items[i] != NULL)
 594		 {
 595		    if (strcmp (nameSchema, doc_items[i]) == 0)
 596		      {
 597			 if (doc_items_menu[i] != NULL)
 598			    strcpy (nameUser, doc_items_menu[i]);
 599			 found = TRUE;
 600		      }
 601		    else
 602		       i++;
 603		 }
 604	       break;
 605
 606	    case CONFIG_NATURE_STRUCT:
 607	       while (i < MAX_ITEM_CONF && !found && nat_items[i] != NULL)
 608		 {
 609		    if (strcmp (nameSchema, nat_items[i]) == 0)
 610		      {
 611			 if (nat_items_menu[i] != NULL)
 612			    strcpy (nameUser, nat_items_menu[i]);
 613			 found = TRUE;
 614		      }
 615		    else
 616		       i++;
 617		 }
 618	       break;
 619
 620	    case CONFIG_EXTENSION_STRUCT:
 621	       while (i < MAX_ITEM_CONF && !found && ext_items[i] != NULL)
 622		 {
 623		    if (strcmp (nameSchema, ext_items[i]) == 0)
 624		      {
 625			 if (ext_items_menu[i] != NULL)
 626			    strcpy (nameUser, ext_items_menu[i]);
 627			 found = TRUE;
 628		      }
 629		    else
 630		       i++;
 631		 }
 632	       break;
 633	 }
 634}
 635
 636
 637/*----------------------------------------------------------------------
 638   ConfigSSchemaInternalName donne le nom du schema de structure qui 
 639   correspond a un nom traduit dans la langue de l'utilisateur.    
 640   Si Doc est vrai, il s'agit d'un schema de document, sinon c'est 
 641   un schema de nature.                                            
 642  ----------------------------------------------------------------------*/
 643void ConfigSSchemaInternalName (char *nameUser, char *nameSchema,
 644				ThotBool Doc)
 645{
 646   int                 i;
 647   ThotBool            found;
 648
 649   i = 0;
 650   found = FALSE;
 651   nameSchema[0] = EOS;
 652   if (Doc)
 653      while (i < MAX_ITEM_CONF && !found && doc_items_menu[i] != NULL)
 654	{
 655	   if (strcmp (nameUser, doc_items_menu[i]) == 0)
 656	     {
 657		if (doc_items[i] != NULL)
 658		   strcpy (nameSchema, doc_items[i]);
 659		found = TRUE;
 660	     }
 661	   else
 662	      i++;
 663	}
 664   else
 665      while (i < MAX_ITEM_CONF && !found && nat_items_menu[i] != NULL)
 666	{
 667	   if (strcmp (nameUser, nat_items_menu[i]) == 0)
 668	     {
 669		if (nat_items[i] != NULL)
 670		   strcpy (nameSchema, nat_items[i]);
 671		found = TRUE;
 672	     }
 673	   else
 674	      i++;
 675	}
 676}
 677#endif /* IV */
 678
 679
 680/*----------------------------------------------------------------------
 681   openConfigFile                                                  
 682  ----------------------------------------------------------------------*/
 683static FILE *openConfigFile (const char *name, ThotBool lang)
 684{
 685   FILE               *file;
 686   const char         *suffix;
 687   int                 i;
 688   PathBuffer          DirBuffer, filename;
 689   char               *app_home;
 690
 691   if (lang)
 692        suffix = "en";
 693   else
 694      suffix = "conf";
 695
 696   /* Search in HOME directory */
 697   app_home = TtaGetEnvString ("APP_HOME");
 698   strcpy (DirBuffer, app_home);
 699   MakeCompleteName (name, suffix, DirBuffer, filename, &i);
 700   if (!TtaFileExist (filename))
 701     {
 702       /* compose le nom du fichier a ouvrir avec le nom du directory */
 703       /* des schemas et le suffixe */
 704       strncpy (DirBuffer, SchemaPath, MAX_PATH);
 705       MakeCompleteName (name, suffix, DirBuffer, filename, &i);
 706       if (!TtaFileExist (filename))
 707	 {
 708	   if (strcmp (name, "Annot"))
 709	     {
 710	       /* it's probably a generic name */
 711	       strncpy (DirBuffer, SchemaPath, MAX_PATH);
 712	       MakeCompleteName ("XML", suffix, DirBuffer, filename, &i);
 713	     }
 714	 }
 715     }
 716   /* ouvre le fichier */
 717   file = TtaReadOpen (filename);
 718   return (file);
 719}
 720
 721/*----------------------------------------------------------------------
 722   ConfigMakeMenuPres cree dans BufMenu la liste des schemas de    
 723   presentation qui peuvent s'appliquer au schema de structure de  
 724   nom schema.                                                     
 725  ----------------------------------------------------------------------*/
 726int ConfigMakeMenuPres (char *schema, char *BufMenu)
 727{
 728   int                 nbitem, len, indmenu;
 729   FILE               *file;
 730   ThotBool            stop;
 731   char                line[MAX_TXT_LEN];
 732   char                text[MAX_TXT_LEN];
 733   char                textISO[MAX_TXT_LEN];
 734   char                word[MAX_TXT_LEN];
 735
 736   nbitem = 0;
 737   indmenu = 0;
 738   if (BufMenu != NULL)
 739      BufMenu[0] = EOS;
 740   file = openConfigFile (schema, TRUE);
 741   if (file == NULL)
 742      return 0;
 743   stop = FALSE;
 744   if (readUntil (file, "presentation", ""))
 745     do
 746       {
 747	 if (fgets (line, MAX_TXT_LEN - 1, file) == NULL)
 748	   stop = TRUE;
 749	 else
 750	   {
 751	     getFirstWord ((unsigned char*)line, word);
 752	     if (word[0] != EOS)
 753	       /* la ligne n'est pas vide */
 754	       {
 755		 /* si la ligne contient un mot cle marquant le debut */
 756		 /* d'une autre section, on a fini */
 757		 if (singleWord ((unsigned char*)line))
 758		   {
 759		     if (strcmp (word, "export") == 0)
 760		       stop = TRUE;
 761		     else if (strcmp (word, "import") == 0)
 762		       stop = TRUE;
 763		     else if (strcmp (word, "translation") == 0)
 764		       stop = TRUE;
 765		   }
 766		 if (!stop)
 767		   {
 768		     getStringAfterColon ((unsigned char*)line, text);
 769		     if (text[0] == EOS)
 770		       fprintf (stderr, "invalid line in file %s\n   %s\n",
 771				schema, line);
 772		     else
 773		       {
 774			 strcpy (textISO, (char *)AsciiTranslate (text));
 775			 if (pres_items[nbitem] != NULL)
 776			   TtaFreeMemory (pres_items[nbitem]);
 777			 pres_items[nbitem] = (char *)TtaGetMemory (strlen(word)+1);
 778			 strcpy (pres_items[nbitem], (char *)word);
 779			 if (pres_items_menu[nbitem] != NULL)
 780			   TtaFreeMemory (pres_items_menu[nbitem]);
 781			 len = strlen (textISO) + 1;
 782			 pres_items_menu[nbitem] = (char *)TtaGetMemory (len);
 783			 strcpy (pres_items_menu[nbitem], (char *)textISO);
 784			 if (BufMenu != NULL)
 785			   {
 786			     strcpy (&BufMenu[indmenu], textISO);
 787			     indmenu += len;
 788			   }
 789			 nbitem++;
 790		       }
 791		   }
 792	       }
 793	   }
 794       }
 795     while (!stop);
 796   TtaReadClose (file);
 797   return nbitem;
 798}
 799
 800/*----------------------------------------------------------------------
 801   ConfigGetPSchemaName recupere dans la table des schemas de       
 802   presentation le nom interne du schema qui se trouve     
 803   a l'entree de rang choix.                               
 804  ----------------------------------------------------------------------*/
 805void ConfigGetPSchemaName (int choix, char *schpres)
 806{
 807   strcpy (schpres, pres_items[choix - 1]);
 808}
 809
 810/*----------------------------------------------------------------------
 811   ConfigMakeImportMenu cree dans BufMenu la liste des schemas de  
 812   structure qui ont des fichiers de langue dans les       
 813   directories de schemas.                                 
 814  ----------------------------------------------------------------------*/
 815int ConfigMakeImportMenu (char *BufMenu)
 816{
 817   int                 nbitem, len, i, lgmenu;
 818
 819   lgmenu = 0;
 820   nbitem = 0;
 821   BufMenu[0] = EOS;
 822   i = 0;
 823
 824   /* parcourt la table des types de documents */
 825   while (i < MAX_ITEM_CONF && doc_items[i] != NULL)
 826     {
 827	if (doc_import[i])
 828	  {
 829	     if (doc_items_menu[i] != NULL)
 830		/* cette entree de la table a une traduction, on la prend */
 831	       {
 832		  len = strlen (doc_items_menu[i]);
 833		  strcpy (&BufMenu[lgmenu], doc_items_menu[i]);
 834	       }
 835	     else
 836		/* pas de traduction, on prend le nom d'origine du schema */
 837	       {
 838		  len = strlen (doc_items[i]);
 839		  strcpy (&BufMenu[lgmenu], doc_items[i]);
 840	       }
 841	     lgmenu += len + 1;
 842	     nbitem++;
 843	  }
 844	i++;
 845     }
 846   return nbitem;
 847}
 848
 849
 850/*----------------------------------------------------------------------
 851   ConfigMakeMenuExport cree dans BufMenu la liste des schemas de  
 852   traduction qui peuvent s'appliquer au schema de structure de    
 853   nom schema.                                                     
 854  ----------------------------------------------------------------------*/
 855int ConfigMakeMenuExport (char *schema, char *BufMenu)
 856{
 857   int                 indmenu;
 858   int                 nbitem, len;
 859   FILE               *file;
 860   ThotBool            stop;
 861   char                line[MAX_TXT_LEN];
 862   char                text[MAX_TXT_LEN];
 863   char                textISO[MAX_TXT_LEN];
 864   char                word[MAX_TXT_LEN];
 865
 866   nbitem = 0;
 867   indmenu = 0;
 868   if (BufMenu != NULL)
 869      BufMenu[0] = EOS;
 870   file = openConfigFile (schema, TRUE);
 871   if (file == NULL)
 872      return 0;
 873   stop = FALSE;
 874   if (readUntil (file, "export", ""))
 875      do
 876	{
 877	   if (fgets (line, MAX_TXT_LEN - 1, file) == NULL)
 878	      stop = TRUE;
 879	   else
 880	     {
 881		getFirstWord ((unsigned char*)line, word);
 882		if (word[0] != EOS)
 883		   /* la ligne n'est pas vide */
 884		  {
 885		    /* si la ligne contient un mot cle marquant le debut */
 886		    /* d'une autre section, on a fini */
 887		     if (singleWord ((unsigned char*)line))
 888		       {
 889			if (strcmp (word, "presentation") == 0)
 890			   stop = TRUE;
 891			else if (strcmp (word, "import") == 0)
 892			   stop = TRUE;
 893			else if (strcmp (word, "translation") == 0)
 894			   stop = TRUE;
 895		       }
 896		     if (!stop)
 897		       {
 898			  getStringAfterColon ((unsigned char*)line, text);
 899			  if (text[0] == EOS)
 900			     fprintf (stderr, "invalid line in file %s\n   %s\n", schema, line);
 901			  else
 902			    {
 903			       strcpy (textISO, (char *)AsciiTranslate (text));
 904			       if (export_items[nbitem] != NULL)
 905				  TtaFreeMemory (export_items[nbitem]);
 906			       export_items[nbitem] = (char *)TtaGetMemory (strlen (word) + 10);
 907			       strcpy (export_items[nbitem], word);
 908			       if (export_items_menu[nbitem] != NULL)
 909				  TtaFreeMemory (export_items_menu[nbitem]);
 910			       len = strlen (textISO) + 1;
 911			       export_items_menu[nbitem] = (char *)TtaGetMemory (len);
 912			       strcpy (export_items_menu[nbitem], textISO);
 913			       if (BufMenu != NULL)
 914				 {
 915				    strcpy (&BufMenu[indmenu], textISO);
 916				    indmenu += len;
 917				 }
 918			       nbitem++;
 919			    }
 920		       }
 921		  }
 922	     }
 923	}
 924      while (!stop);
 925   TtaReadClose (file);
 926   return nbitem;
 927}
 928
 929/*----------------------------------------------------------------------
 930   ConfigGetExportSchemaName recupere dans la table des schemas de  
 931   traduction le nom interne du schema qui se trouve       
 932   a l'entree de rang choix.                               
 933  ----------------------------------------------------------------------*/
 934void ConfigGetExportSchemaName (int choix, char *schtrad)
 935{
 936   strcpy (schtrad, export_items[choix - 1]);
 937}
 938
 939
 940/*----------------------------------------------------------------------
 941   Translate                                                       
 942  ----------------------------------------------------------------------*/
 943static ThotBool Translate (PtrSSchema pSS, char *word, char *trans)
 944{
 945   ThotBool            found;
 946   int                 i, j;
 947   PtrTtAttribute      pAttr;
 948
 949   found = FALSE;
 950   /* cherche le mot a traduire d'abord parmi les noms d'elements */
 951   for (i = 0; i < pSS->SsNRules; i++)
 952     if (pSS->SsRule->SrElem[i]->SrName != NULL &&
 953	 strcmp ((char *)AsciiTranslate (word), pSS->SsRule->SrElem[i]->SrName) == 0)
 954       {
 955	 TtaFreeMemory (pSS->SsRule->SrElem[i]->SrName);
 956	 pSS->SsRule->SrElem[i]->SrName = TtaStrdup ((char *)AsciiTranslate (trans));
 957	 found = TRUE;
 958       }
 959
 960   /* cherche ensuite parmi les noms d'attributs et de valeurs d'attributs */
 961   for (i = 0; i < pSS->SsNAttributes; i++)
 962	{
 963	   pAttr = pSS->SsAttribute->TtAttr[i];
 964	   if (pAttr->AttrName != NULL &&
 965	       strcmp ((char *)AsciiTranslate (word), pAttr->AttrName) == 0)
 966	     {
 967	       TtaFreeMemory (pAttr->AttrName);
 968	       pAttr->AttrName = TtaStrdup ((char *)AsciiTranslate (trans));
 969	       found = TRUE;
 970	     }
 971	   else if (pAttr->AttrType == AtEnumAttr)
 972	      for (j = 0; j < pAttr->AttrNEnumValues; j++)
 973		 if (strcmp ((char *)AsciiTranslate (word), pAttr->AttrEnumValue[j]) == 0)
 974		   {
 975		      strncpy (pAttr->AttrEnumValue[j],
 976			       (char *)AsciiTranslate (trans), MAX_NAME_LENGTH - 1);
 977		      found = TRUE;
 978		   }
 979	}
 980
 981   /* cherche enfin parmi les regles d'extension, si c'est un schema d'extension */
 982   if (pSS->SsExtension)
 983      if (pSS->SsNExtensRules > 0 && pSS->SsExtensBlock != NULL)
 984	 for (i = 0; i < pSS->SsNExtensRules; i++)
 985	    if (pSS->SsExtensBlock->EbExtensRule[i].SrName != NULL &&
 986		strcmp ((char *)AsciiTranslate (word), pSS->SsExtensBlock->EbExtensRule[i].SrName) == 0)
 987	      {
 988		TtaFreeMemory (pSS->SsExtensBlock->EbExtensRule[i].SrName);
 989		pSS->SsExtensBlock->EbExtensRule[i].SrName =
 990		  TtaStrdup ((char *)AsciiTranslate (trans));
 991		found = TRUE;
 992	      }
 993   return found;
 994}
 995
 996/*----------------------------------------------------------------------
 997   ConfigTranslateSSchema                                          
 998  ----------------------------------------------------------------------*/
 999void ConfigTranslateSSchema (PtrSSchema pSS)
1000{
1001   FILE    *file;
1002   char    *line;
1003   char    *text;
1004   char    *word;
1005   ThotBool stop, error;
1006
1007   if (pSS == NULL)
1008      return;
1009   /* ouvre le fichier de configuration langue associe' au schema */
1010   file = openConfigFile (pSS->SsName, TRUE);
1011   if (file == NULL) 
1012      /* pas de fichier langue associe' a ce schema de structure */
1013      return;
1014   stop = FALSE;
1015   /* avance dans le fichier jusqu'a la ligne qui contient le seul */
1016   /* mot "translation" */
1017   line = (char *)TtaGetMemory (MAX_TXT_LEN);
1018   text = (char *)TtaGetMemory (MAX_TXT_LEN);
1019   word = (char *)TtaGetMemory (MAX_TXT_LEN);
1020   if (readUntil (file, "translation", ""))
1021      /* lit le fichier ligne a ligne */
1022      do
1023	{
1024	   error = FALSE;
1025	   /* lit une ligne du fichier */
1026
1027	   if (fgets (line, MAX_TXT_LEN - 1, file) == NULL)
1028	      /* fin de fichier */
1029	      stop = TRUE;
1030	   else
1031	     {
1032		/* prend le premier mot de la ligne */
1033		getFirstWord ((unsigned char*)line, word);
1034		if (word[0] != EOS)
1035		   /* la ligne n'est pas vide */
1036		  {
1037		    /* si la ligne contient un mot cle marquant le debut */
1038		    /* d'une autre section, on a fini */
1039		    if (singleWord ((unsigned char*)line))
1040		      {
1041			if (strcmp (word, "presentation") == 0)
1042			  stop = TRUE;
1043			else if (strcmp (word, "export") == 0)
1044			  stop = TRUE;
1045			else if (strcmp (word, "import") == 0)
1046			  stop = TRUE;
1047			else
1048			  {
1049			  fprintf (stderr, "invalid line in file %s\n   %s\n",
1050				   pSS->SsName, line);
1051			  error = TRUE;
1052			  }
1053		      }
1054		    if (!stop && !error)
1055		      {
1056			/* cherche la chaine de caracteres qui suit ':' */
1057			getStringAfterColon ((unsigned char*)line, text);
1058			if (text[0] == EOS)
1059			  fprintf (stderr, "invalid line in file %s\n   %s\n",
1060				   pSS->SsName, line);
1061			else if (!Translate (pSS, word, text))
1062			  fprintf (stderr, "invalid line in file %s\n   %s\n",
1063				   pSS->SsName, line);
1064		      }
1065		  }
1066	     }
1067	}
1068      while (!stop);
1069   TtaFreeMemory (line);
1070   TtaFreeMemory (text);
1071   TtaFreeMemory (word);
1072   TtaReadClose (file);
1073}
1074
1075/*----------------------------------------------------------------------
1076   ConfigDefaultPSchema    retourne dans schpres le nom du 1er     
1077   schema de presentation associe' au schema de structure schstr   
1078   dans le fichier .conf correspondant.                            
1079   Retourne FALSE si pas trouve', TRUE si OK.                      
1080  ----------------------------------------------------------------------*/
1081ThotBool ConfigDefaultPSchema (char *schstr, char **schpres)
1082{
1083   ThotBool            ok, stop;
1084   FILE               *file;
1085   char                line[MAX_TXT_LEN];
1086   char                word[MAX_TXT_LEN];
1087
1088   ok = FALSE;
1089   *schpres = NULL;
1090   /* ouvre le fichier .conf associe' au schema de structure */
1091   file = openConfigFile (schstr, FALSE);
1092   if (file != NULL)
1093      /* on a ouvert le fichier .conf */
1094     {
1095	/* on cherche la premiere ligne qui commence par le mot "style" */
1096	stop = FALSE;
1097	do
1098	   /* lit une ligne */
1099	   if (fgets (line, MAX_TXT_LEN - 1, file) == NULL)
1100	      /* fin de fichier */
1101	      stop = TRUE;
1102	   else
1103	     {
1104		/* prend le premier mot de la ligne */
1105		getFirstWord ((unsigned char*)line, word);
1106		if (strcmp (word, "style") == 0)
1107		  {
1108		     /* le 1er mot est "style". Cherche le mot qui suit : c'est le */
1109		     /* nom du schema de presentation cherche' */
1110		     getSecondWord ((unsigned char *)line, word);
1111		     if (word[0] != EOS)
1112			/* il y a bien un 2eme mot : succes */
1113		       {
1114			  *schpres = TtaStrdup (word);
1115			  ok = TRUE;
1116		       }
1117		     stop = TRUE;
1118		  }
1119	     }
1120	while (!stop);
1121	TtaReadClose (file);
1122     }
1123   return ok;
1124}
1125
1126/*----------------------------------------------------------------------
1127   readUntilStyle  lit le fichier file (qui doit etre ouvert)      
1128   jusqu'a trouver une ligne qui contienne le mot "style"  
1129   suivi du nom namePSchema.                                
1130   Retourne TRUE si trouve, FALSE sinon.                   
1131  ----------------------------------------------------------------------*/
1132static ThotBool readUntilStyle (FILE *file, char *namePSchema)
1133{
1134   ThotBool            stop;
1135   ThotBool            ok;
1136   char                line[MAX_TXT_LEN];
1137   char                word[MAX_TXT_LEN];
1138   char                name[MAX_TXT_LEN];
1139
1140   stop = FALSE;
1141   ok = FALSE;
1142   do
1143     if (fgets (line, MAX_TXT_LEN - 1, file) == NULL)
1144        /* fin de fichier */
1145        stop = TRUE;
1146     else
1147        {
1148           getFirstWord ((unsigned char*)line, word);
1149           if (strcmp (word, "style") == 0)
1150              {
1151                 getSecondWord ((unsigned char *)line, word);
1152                 strcpy (name, word);
1153                 if (strcmp (name, namePSchema) == 0 ||
1154		     strcmp (name, "XMLP") == 0)
1155                    ok = TRUE;
1156              }
1157        }
1158   while (!stop && !ok);
1159   return ok;
1160}
1161
1162/*----------------------------------------------------------------------
1163   openConfFileAndReadUntil ouvre le fichier .conf qui concerne    
1164   le schema de structure pSS et avance dans ce fichier    
1165   jusqu'a la ligne qui marque la section de nom sectName. 
1166   Retourne le file descriptor du fichier si on a trouve'  
1167   le fichier .conf et la section, NULL sinon.             
1168  ----------------------------------------------------------------------*/
1169static FILE *openConfFileAndReadUntil (PtrSSchema pSS, const char *sectName)
1170{
1171   FILE    *file;
1172
1173   /* ouvre le fichier .conf */
1174   file = NULL;
1175   if (pSS != NULL) 
1176      file = openConfigFile (pSS->SsName, FALSE);
1177  
1178   if (file != NULL)
1179      /* on a ouvert le fichier */
1180     {
1181      /* cherche la ligne "style xxxx" qui correspond au schema P concerne' */
1182      if (!readUntilStyle (file, pSS->SsDefaultPSchema))
1183	 /* pas trouve' */
1184	{
1185	   TtaReadClose (file);
1186	   file = NULL;
1187	}
1188      else
1189	 /* cherche le debut de la section voulue */
1190      if (!readUntil (file, sectName, ""))
1191	 /* pas trouve' */
1192	{
1193	   TtaReadClose (file);
1194	   file = NULL;
1195	}
1196     }
1197   return file;
1198}
1199
1200
1201/*----------------------------------------------------------------------
1202   getNextLineInSection    lit dans line la prochaine ligne du     
1203   fichier file qui fasse partie de la meme section.       
1204   Retourne TRUE si succes, FALSE si on a atteint la fin   
1205   de la section courante ou du fichier.                   
1206  ----------------------------------------------------------------------*/
1207static ThotBool getNextLineInSection (FILE * file, char *line)
1208{
1209   ThotBool          ok, stop;
1210   char              word1[MAX_TXT_LEN];
1211   char              word2[MAX_TXT_LEN];
1212
1213   ok = FALSE;
1214   stop = FALSE;
1215   do
1216      /* lit une ligne */
1217      if (fgets (line, MAX_TXT_LEN - 1, file) == NULL)
1218	 /* fin de fichier */
1219	 stop = TRUE;
1220      else
1221	{
1222	   /* prend le permier mot de la ligne lue */
1223	   getFirstWord ((unsigned char*)line, word1);
1224	   if (word1[0] != EOS)
1225	      /* la ligne n'est pas vide */
1226	     {
1227		/* si la ligne contient un mot cle marquant le debut d'une autre */
1228		/* section, on a fini */
1229		if (singleWord ((unsigned char*)line))
1230		   /* la ligne contient un seul mot */
1231		  {
1232		     if (strcmp (word1, "open") == 0)
1233			stop = TRUE;
1234		     else if (strcmp (word1, "geometry") == 0)
1235			stop = TRUE;
1236		     else if (strcmp (word1, "presentation") == 0)
1237			stop = TRUE;
1238		     else if (strcmp (word1, "options") == 0)
1239			stop = TRUE;
1240		     else
1241			/* ligne contenant un seul mot. on considere que c'est OK... */
1242			ok = TRUE;
1243		  }
1244		else
1245		   /* la ligne contient plus d'un mot */
1246		if (strcmp (word1, "style") == 0)
1247		  {
1248		     getSecondWord ((unsigned char *)line, word2);
1249		     if (word2[0] != ':')
1250			/* la ligne est du type "style xxxx". C'est une fin de section */
1251			stop = TRUE;
1252		     else
1253			ok = TRUE;
1254		  }
1255		else
1256		   /* la ligne ne commence pas par "style". OK */
1257		   ok = TRUE;
1258	     }
1259	}
1260   while (!stop && !ok);
1261   return ok;
1262}
1263
1264/*----------------------------------------------------------------------
1265   ConfigKeyboard.                                                     
1266  ----------------------------------------------------------------------*/
1267void             ConfigKeyboard (int *x, int *y)
1268{
1269   FILE         *file;
1270   char        seqLine[MAX_TXT_LEN];
1271   char          line[MAX_TXT_LEN];
1272   int           nbIntegers;
1273
1274   *x = 600;
1275   *y = 100;
1276   file = openConfigFile ("keyboard", FALSE);
1277   if (file == NULL)
1278      return;
1279
1280   getNextLineInSection (file, line);
1281
1282   /* extrait la partie de la ligne qui suit les deux-points */
1283   getStringAfterColon ((unsigned char*)line, seqLine);
1284   if (seqLine[0] != EOS)
1285     /* extrait les 4 entiers */
1286     nbIntegers = sscanf (seqLine, "%d %d", x, y);
1287   TtaReadClose (file);
1288}
1289
1290/*----------------------------------------------------------------------
1291  getXYWidthHeight        
1292  Lit les 4 entiers x, y, width, height qui suivent les deux-points 
1293  dans une ligne de la section open ou geometry d'un fichier .conf                     
1294  Retourne TRUE si succes.                                
1295  ----------------------------------------------------------------------*/
1296static ThotBool getXYWidthHeight (char *line, PtrDocument pDoc, int *x,
1297                                  int *y, int *width, int *height)
1298{
1299  char       seqLine[MAX_TXT_LEN];
1300  int        nbIntegers;
1301  ThotBool   result;
1302
1303  result = FALSE;
1304  /* extrait la partie de la ligne qui suit les deux-points */
1305  getStringAfterColon ((unsigned char*)line, seqLine);
1306  if (seqLine[0] != EOS)
1307    {
1308      /* extrait les 4 entiers */
1309      nbIntegers = sscanf (seqLine, "%d %d %d %d", x, y, width, height);
1310      if (nbIntegers != 4)
1311        fprintf (stderr, "invalid line in file %s.conf\n   %s\n",
1312                 pDoc->DocSSchema->SsName, line);
1313      else
1314        result = TRUE;
1315    }
1316  /* check the position/size is coherent */
1317  if (*x < 0)
1318    *x = 0;
1319  if (*y < 0)
1320    *y = 0;
1321  if (*width <= 0)
1322    *width = 800;
1323  if (*height <= 0)
1324    *height = 600;
1325  return result;
1326}
1327
1328/*----------------------------------------------------------------------
1329   ConfigOpenFirstViews ouvre, pour le document pDoc, les vues     
1330   specifiees dans la section open du fichier de           
1331   configuration .conf                                     
1332  ----------------------------------------------------------------------*/
1333void ConfigOpenFirstViews (PtrDocument pDoc)
1334{
1335   FILE               *file;
1336   int                 x, y, width, height;
1337   char                line[MAX_TXT_LEN];
1338   char                nameview[MAX_TXT_LEN];
1339
1340   /* ouvre le fichier .conf du document et avance jusqu'a la section "open" */
1341   file = openConfFileAndReadUntil (pDoc->DocSSchema, "open");
1342   if (file != NULL)
1343      {
1344         /* on a trouve' le debut de la section open. On lit le fichier .conf */
1345         /* ligne par ligne, jusqu'a la fin de cette section */
1346         while (getNextLineInSection (file, line))
1347               {
1348                  /* le 1er mot de la ligne est le nom d'une vue a ouvrir */
1349                  getFirstWord ((unsigned char*)line, nameview);
1350                  /* lit les coordonnees (x, y) et dimensions (width, height) de la */
1351                  /* frame ou doit s'afficher la vue */
1352                  if (getXYWidthHeight (line, pDoc, &x, &y, &width, &height))
1353                     /* lecture reussie, on ouvre la vue */
1354                     OpenViewByName (pDoc, nameview, x, y, width, height);
1355               }
1356         TtaReadClose (file);
1357      }
1358}
1359
1360/*----------------------------------------------------------------------
1361  ConfigGetViewGeometry retourne la position (x, y) et les        
1362  dimensions (width, height) de la fenetre ou doit        
1363  s'afficher la vue de non view pour le document pDoc.     
1364  ----------------------------------------------------------------------*/
1365void  ConfigGetViewGeometry (PtrDocument pDoc, const char *view, int *x,
1366                             int *y, int *width, int *height)
1367{
1368  FILE               *file;
1369  char               line[MAX_TXT_LEN];
1370  char               nameview[MAX_TXT_LEN];
1371  ThotBool           found;
1372
1373  *x = 0;
1374  *y = 0;
1375  *width = 0;
1376  *height = 0;
1377
1378  /* ouvre le fichier .conf du document et avance jusqu'a la section 
1379     "open" */
1380  file = openConfFileAndReadUntil (pDoc->DocSSchema, "open");
1381  if (file != NULL)
1382    {
1383      /* on a trouve' le debut de la section open. On lit le fichier 
1384         .conf ligne par ligne, jusqu'a la ligne qui commence par le 
1385         name de la vue */
1386      found = FALSE;
1387      while (!found && getNextLineInSection (file, line))
1388        {
1389          /* le 1er mot de la ligne est le nom d'une vue */
1390          getFirstWord ((unsigned char*)line, nameview);
1391          /* est-ce le nom de la vue cherchee ? */
1392          found = (strcmp (nameview, view) == 0);
1393        }
1394      if (!found)
1395        /* on n'a pas trouve' dans la section "open". On cherche dans la
1396           section "geometry" */
1397        {
1398          TtaReadClose (file);
1399          file = openConfFileAndReadUntil (pDoc->DocSSchema, "geometry");
1400          if (file != NULL)
1401            while (!found && getNextLineInSection (file, line))
1402              {
1403                /* le 1er mot de la ligne est le nom d'une vue */
1404                getFirstWord ((unsigned char*)line, nameview);
1405                /* est-ce le nom de la vue cherchee ? */
1406                found = (strcmp (nameview, view) == 0);
1407              }
1408        }
1409      TtaReadClose (file);
1410      if (found)
1411        getXYWidthHeight (line, pDoc, x, y, width, height);
1412    }
1413}
1414
1415/*----------------------------------------------------------------------
1416   TtaGetViewFullscreen returns true if the current window is fullscreen
1417  ----------------------------------------------------------------------*/
1418ThotBool TtaGetViewFullscreen(Document doc, int view)
1419{
1420#ifdef _WX
1421  int window_id = TtaGetDocumentWindowId( doc, -1 ); 
1422  AmayaWindow * p_window = TtaGetWindowFromId( window_id );
1423  if (p_window)
1424    return p_window->IsFullScreen();
1425  else
1426    return FALSE;
1427#else /* _WX */
1428  return FALSE;
1429#endif /* _WX */
1430}
1431
1432/*----------------------------------------------------------------------
1433   TtaGetViewIconized returns true if the current window is maximized
1434  ----------------------------------------------------------------------*/
1435ThotBool TtaGetViewIconized(Document doc, int view)
1436{
1437#ifdef _WX
1438  int window_id = TtaGetDocumentWindowId( doc, -1 ); 
1439  AmayaWindow * p_window = TtaGetWindowFromId( window_id );
1440  if (p_window)
1441    return p_window->IsIconized();
1442  else
1443    return FALSE;
1444#else /* _WX */
1445  return FALSE;
1446#endif /* _WX */
1447}
1448
1449/*----------------------------------------------------------------------
1450   TtaGetViewMaximize returns true if the current window is maximized
1451  ----------------------------------------------------------------------*/
1452ThotBool TtaGetViewMaximized(Document doc, int view)
1453{
1454#ifdef _WX
1455  int window_id = TtaGetDocumentWindowId( doc, -1 ); 
1456  AmayaWindow * p_window = TtaGetWindowFromId( window_id );
1457  if (p_window)
1458    return p_window->IsMaximized();
1459  else
1460    return FALSE;
1461#else /* _WX */
1462  return FALSE;
1463#endif /* _WX */
1464}
1465
1466/*----------------------------------------------------------------------
1467   TtaGetViewXYWH returns the current geometry (x, y, width, and height)
1468   values associated with the frame where a view is displayed
1469  ----------------------------------------------------------------------*/
1470void TtaGetViewXYWH (Document doc, int view, int *xmm, int *ymm, int *width,
1471                     int *height)
1472{
1473#ifdef _WX
1474  int window_id = TtaGetDocumentWindowId( doc, -1 );
1475  if (window_id < 0)
1476    {
1477      *xmm = 0;
1478      *ymm = 0;
1479      *width = 800;
1480      *height = 600;
1481      return;
1482    }
1483  
1484  *width = WindowTable[window_id].FrWidth;
1485  *height = WindowTable[window_id].FrHeight;
1486  
1487  AmayaWindow * p_window = TtaGetWindowFromId( window_id );
1488  p_window->GetPosition( xmm, ymm );
1489
1490  /* check the position/size is coherent */
1491  if (*xmm < 0)
1492    *xmm = 0;
1493  if (*ymm < 0)
1494    *ymm = 0;
1495  if (*width < 0)
1496    *width = 800;
1497  if (*height < 0)
1498    *height = 600;
1499#endif /* _WX */
1500#ifdef _WINGUI
1501  int  frame;
1502  HWND hWnd;
1503  RECT rect;
1504
1505  frame = GetWindowNumber (doc, view);
1506  hWnd = FrMainRef[frame];
1507  /* ask Windows what's the geometry of the frame */
1508  if (!GetWindowRect (hWnd, &rect))
1509    *width = *height = 0;
1510  else 
1511    {
1512      /* convert the result into mm */
1513      *xmm = (int) (rect.left);
1514      *ymm = (int) (rect.top);
1515      *width = (int) (rect.right - rect.left);
1516      *height = (int) (rect.bottom - rect.top);
1517    }
1518#endif /* _WINGUI */
1519  return;
1520}
1521
1522/*----------------------------------------------------------------------
1523   TtaGetViewGeometryRegistry ret;urns the position (x, y) and sizes        
1524   (width, height) of the frame where the view is displayed. These values
1525   are read from the Thot registry.
1526   Parameters:    document: the document.                  
1527   name: the name of the view in P schema.  
1528  ----------------------------------------------------------------------*/
1529void TtaGetViewGeometry (Document document, const char *name, int *x, int *y,
1530                         int *width, int *height)
1531{
1532  PtrDocument pDoc;
1533  char        line[MAX_TXT_LEN];
1534  char       *ptr;
1535
1536  
1537  UserErrorCode = 0;
1538  *x = 0;
1539  *y = 0;
1540  *width = 0;
1541  *height = 0;;
1542
1543  if (document < 1 || document > MAX_DOCUMENTS)
1544    TtaError (ERR_invalid_document_parameter);
1545  else if (document != 0)
1546    {
1547      pDoc = LoadedDocument[document - 1];
1548      ptr = TtaGetEnvString (name);
1549      if (!ptr || ptr[0] == EOS)
1550        ConfigGetViewGeometry (pDoc, name, x, y, width, height);
1551      else
1552        {
1553          sprintf (line, ":%s", ptr);
1554          getXYWidthHeight (line, pDoc, x, y, width, height);
1555        }
1556    } 
1557}
1558
1559/*----------------------------------------------------------------------
1560   TtaGetViewGeometryMM returns the position (x, y) and sizes        
1561   (width, height) of the frame where a view is displayed. The values
1562   returned are in mm
1563   Parameters:    document: the document.                  
1564   name: the name of the view in P schema.  
1565  ----------------------------------------------------------------------*/
1566void  TtaGetViewGeometryMM (Document document, char *name, int *x,
1567			    int *y, int *width, int *height)
1568{
1569   TtaGetViewGeometry (document, name, x, y, width, height);
1570}
1571
1572/*----------------------------------------------------------------------
1573   ConfigGetPSchemaNature retourne dans presNature le nom du       
1574   schema de presentation a appliquer a la nature de nom   
1575   nameNature dans le contexte du schema de structure pSS   
1576  ----------------------------------------------------------------------*/
1577ThotBool ConfigGetPSchemaNature (PtrSSchema pSS, char *nameNature,
1578				 char **presNature)
1579{
1580   FILE               *file;
1581   char                line[MAX_TXT_LEN];
1582   char                seqLine[MAX_TXT_LEN];
1583   char                name[MAX_TXT_LEN];
1584   ThotBool            found;
1585   ThotBool            ok;
1586
1587   *presNature = NULL;
1588   ok = FALSE;
1589   /* ouvre le fichier .conf du document et avance jusqu'a la section "presentation" */
1590   file = openConfFileAndReadUntil (pSS, "presentation");
1591   if (file != NULL)
1592     {
1593	/* on a trouve' le debut de la section presentation. On lit le fichier */
1594	/* ligne par ligne jusqu'a la ligne qui commence par le nom de la nature */
1595	found = FALSE;
1596	while (!found && getNextLineInSection (file, line))
1597	  {
1598	     /* le 1er mot de la ligne est le nom d'une nature */
1599	     getFirstWord ((unsigned char*)line, name);
1600	     /* est-ce le nom de la nature cherchee ? */
1601	     found = (strcmp (name, nameNature) == 0);
1602	  }
1603	if (found)
1604	   /* on a trouve' la ligne de la section presentation qui commence par */
1605	   /* le nom de la nature voulue */
1606	  {
1607	     /* le nom de nature est suivi, apres ":", du nom du schema de */
1608	     /* presentation a appliquer */
1609	     getStringAfterColon ((unsigned char*)line, seqLine);
1610	     if (seqLine[0] == EOS)
1611		fprintf (stderr, "invalid line in file %s.conf\n   %s\n", pSS->SsName, line);
1612	     else
1613	       {
1614		  *presNature = TtaStrdup (seqLine);
1615		  ok = TRUE;
1616	       }
1617	  }
1618	TtaReadClose (file);
1619     }
1620   return ok;
1621}
1622
1623/*----------------------------------------------------------------------
1624   ConfigGetPresentationOption cherche, dans le fichier .conf      
1625   correspondant au schema de structure pSS, la valeur     
1626   de l'…

Large files files are truncated, but you can click here to view the full file