unit uConstantesSimSEE;

{$MODE Delphi}
interface

uses
{$IFDEF LINUX}
  winLinuxUtils,
{$ENDIF}
{$IFDEF WINDOWS}
  {$IFNDEF APLICACION_CONSOLA}
  Forms, Messages,
  {$ENDIF}
{$ELSE}
{$IFNDEF APLICACION_CONSOLA}
  Forms, LMessages,
  //Messages,
  Graphics,
  {$ELSE}
  {$IFDEF WINDOWS}
  uWinMsgs,
  {$ENDIF}
  {$ENDIF}
{$ENDIF}
  SysUtils;

const
{$IFNDEF APLICACION_CONSOLA}
  WM_CLOSETRAZOSXY = WM_USER + 1; //Mensaje para cerrar una ventana TrazosXY
{$ENDIF}
  CF_PRECISION = 10;
  CF_DECIMALES = 10;
  CF_DECIMALESPU = 12; //para valores por unidad
  //Nombre de la fuente NIL para los formularios de edicion
  nombreFuenteNil = '<Ninguna>';


var
  // Intento quitar tmp_rundir de aquí, para que cada Hilo pueda tener su propio
  // directorio.
  //  tmp_rundir: string; // si se fija a un valor <> '' se usa como rundir.

  base_ScreenWidth, base_ScreenHeight: integer;
  CP_maxAnchoTablaChica, CP_maxAnchoTablaMediana, CP_maxAnchoTablaGrande,
  CP_maxAnchoTablaMuyGrande, CP_maxAnchoTablaEnorme: integer;
  CP_maxAlturaTablaChica, CP_maxAlturaTablaMediana, CP_maxAlturaTablaGrande,
  CP_maxAlturaTablaMuyGrande, CP_maxAlturaTablaEnorme: integer;


var
  tmp_rundir: string;
  {$IFDEF CursoRuben}
  dirSala: string;
  {$ENDIF}

function getDir_SimSEE: string;
function getDir_Dbg: string;
function getDir_Bin: string;
function getDir_Run: string;
function getDir_Docs: string;
function getDir_Lib: string;
function getDir_DatosComunes: string;
function getDir_Corridas: string;
function getDir_Tmp: string;
function getDir_CacheNube: string;
function getDir_CacheOddFace: string;

function getDir_SimSEE_ws: string;

function get_cv_falla: double;

// Retorna el nombre del archivo quitando la path y la extensión.
function nombreArchSinExtension(const nomArch: string): string;

//Retorna la unidad actual seguida de :. P.ej: 'C:'
function getCurrentDrive: string;
{$IFDEF LINUX}
//Intenta transformar los paths a paths de linux. Si no se encuentra el archivo
//indicado por path se cambia path por
//HOME + LowerCase(ExtractFilePath(path)) + ExtractFileName(path),
//con HOME el valor de la variable de entorno HOME. Si la variable HOME no esta
//definida se asume HOME = /home/topo
procedure toLinuxDir(var path: string);
{$ENDIF}


// retorna la carpeta madre de path terminada en DirectorySeparator
procedure subirDirectorio(var path: string);

function quitarRaiz_(path: string): string;

// retorna el archivo sin la extensión
function quitarExtension(archi: string): string;

//Revisa que existan los directorios necesarios para el SimSEE y en caso de no
//existir los crea.
procedure crearDirectorios;


// en Linux es /tmp/simsee_USUARIO siendo
// USUARIO en nombre del usuario que esta ejecutando.
// en Windows es \SimSEE\tmp_rundir
// si en el directorio de la aplicación encuentra un archivo tmp_base.cfg
// considera la primera línea del archivo como la carpeta tmp_base.cfg
function getDefault_tmp_base: string;

// temporal - versión anterior la dejo un tiempito para limpiar la carpeta
// temporal del cluster-UY luego borrar 20181209
// Cuando se borre esta función también hay que acomodar el chequeo en las
// funciones EliminarCarpetasViejas y LimpiarCarpeta que quedaron contaminadas.
function getDefault_tmp_base_OLD_: string;


// Crea directorio temporal para el idEjecutor en la carpeta tmp_base
// Retorna el camino completo a la carpeta tmp_base+ DirectorySeparator + idEjecutor
function CrearDirectorioTemporal(tmp_base, idEjecutor: string;
  idSubCarpetaSalida: string = ''): string;

// si dir <> '' elimina los archivos y luego lo remueve.
// por seguirdad se exige que la carpeta tenga "simsee"
procedure EliminarCarpeta(const DirName: string);

// Llama EliminarCarpeta, para las subcarpetas de baseDir cuya fecha sea
// de hace más de nHoras
procedure EliminarCarpetasViejas(const baseDir: string; nHoras: integer);


// Borra el contenido de una carpeta.
// por seguridad se exige que la carpeta tenga es string "simsee".
procedure LimpiarCarpeta(const DirName, mascara: string; flg_FORCE: boolean = false );



//Borra el contenideo de la carpeta, sin exigir nada sobre el nombre
//de la carpeta
function LimpiarResultadosSim(var carpeta: string; archiComodin: string): integer;

// cambia una letra por otra en un string;
procedure remplazar_letra(var pajar: string; aguja, reemplazo: char);

//Cambia el nombre del archivo a la carpeta de nomArchivo\backups\nomArchivo.bak
//No crea una copia, por lo que debe llamarse cuando se va a salvar un nuevo archivo
//sobre nomArchivo
procedure backupearArchivoAntesDeSalvar(nomArchivo: string; maxNBackups: integer);

procedure calcularTamaniosTablas(altoDisponible, anchoDisponible: integer;
  ajustarATamaniosCeldasPorDefecto: boolean);

implementation


(* Retorna el directorio padre terminado con barraDir
Ej1: path = 'c:\simsee\bin\' retorna path = 'c:\simsee\'
Ej2: path = 'c:\simsee\bin' retorna path = 'c:\simsee\'
Ej3: path = 'c:\sim' retorna path = 'c:\'
Ej4: path = 'c:\' retorna path = '\'
Ej4: path = 'adsfadsf\' retorna path = '\'
*)
procedure subirDirectorio(var path: string);
var
  i, N: integer;
  buscando: boolean;
begin
  N := length(path);
  if N < 1 then
  begin
    path := DirectorySeparator; // cubre el caso path=''  y path='x'
    exit;
  end;

  buscando := True;
  i := N - 1; // me salteo el último caracter pues si es una barra quiero ignorarla

  while buscando and (i > 0) do
    if path[i] = DirectorySeparator then
      buscando := False
    else
      Dec(i);
  if buscando then
    path := DirectorySeparator
  else
    Delete(path, i + 1, N - i);
end;


function quitarRaiz_(path: string): string;
var
  i: integer;
  s: string;
begin
  i := pos(':', path);
  if i <> 0 then
    s := copy(path, i + 1, MAXINT)
  else
    s := path;
  Result := trim(s);
end;



procedure remplazar_letra(var pajar: string; aguja, reemplazo: char);
var
  k, n: integer;
begin
  n := length(pajar);
  for k := 1 to n do
    if pajar[k] = aguja then
      pajar[k] := reemplazo;
end;

procedure EliminarCarpeta(const DirName: string);
begin
  if (pos('simsee', DirName) = 0) and (pos('/scratch/', DirName) = 0) then
    exit; // no permitimos borrar nada que no tenga simsee en el camino
  limpiarCarpeta(DirName, '*.*');
  removeDir(DirName);
end;


// Llama EliminarCarpeta, para las subcarpetas de baseDir cuya fecha sea
// de hace más de nHoras
procedure EliminarCarpetasViejas(const BaseDir: string; nHoras: integer);
var
  Error: integer;
  FileSearch: TSearchRec;
  camino: string;
  xmascara: string;
  dtUltimaModificacion: TDateTime;

begin

  if (pos('simsee', BaseDir) = 0) and (pos('/scratch/', BaseDir) = 0) then
    exit; // no permitimos borrar nada que no tenga simsee en el camino

  {$IFDEF LINUX}
  xmascara := '*';
  {$ELSE}
  xmascara := '*.*';
  {$ENDIF}

  if BaseDir[Length(BaseDir)] = DirectorySeparator then
    camino := BaseDir
  else
    camino := BaseDir + DirectorySeparator;

  writeln('Revisando para borrar subcarpetas de: ', camino);

  Error := FindFirst(camino + xmascara, faDirectory, FileSearch);
  try
    while (Error = 0) do
    begin
      if (FileSearch.Name <> '.') and (FileSearch.Name <> '..') then
      begin
        dtUltimaModificacion := FileDateToDateTime(FileSearch.Time);
        if ((now - dtUltimaModificacion) * 24) > nHoras then
        begin
          writeln('Eliminando carpeta: ', FileSearch.Name, ', dt: ',
            DateTimeToStr(dtUltimaModificacion));
          EliminarCarpeta(camino + FileSearch.Name);
        end
        else
        begin
          writeln('Dejando carpeta: ', FileSearch.Name, ', dt: ',
            DateTimeToStr(dtUltimaModificacion));
        end;
      end;
      Error := FindNext(FileSearch);
    end;
  finally
    SysUtils.FindClose(FileSearch);
  end;
end;


procedure LimpiarCarpeta( const DirName, mascara: string; flg_FORCE: boolean = false  );
var
  Error: integer;
  FileSearch: TSearchRec;
  camino: string;
  xmascara: string;
begin
  if (not flg_FORCE) and (pos('simsee', DirName) = 0) and (pos('SimSEE', DirName) = 0) then
    exit; // no permitimos borrar nada que no tenga simsee en el camino

  {$IFDEF LINUX}
  if mascara = '*.*' then
    xmascara := '*'
  else
    xmascara := mascara;
  {$ELSE}
  if mascara = '*' then
    xmascara := '*.*'
  else
    xmascara := mascara;
  {$ENDIF}

  if DirName[Length(DirName)] = DirectorySeparator then
    camino := DirName
  else
    camino := DirName + DirectorySeparator;

  Error := FindFirst(camino + xmascara, faAnyFile, FileSearch);
  try
    while (Error = 0) do
    begin
      if (FileSearch.Name <> '.') and (FileSearch.Name <> '..') then
        SysUtils.DeleteFile(camino + FileSearch.Name);
      Error := FindNext(FileSearch);
    end;
  finally
    SysUtils.FindClose(FileSearch);
  end;
end;

function LimpiarResultadosSim(var carpeta: string; archiComodin: string): integer;
var
  res: integer;
  Info: TSearchRec;

begin
  carpeta := ExtractFilePath(archiComodin);
  res := 0;
  if FindFirst(archiComodin, faArchive, Info) = 0 then
  begin
    repeat
      SysUtils.DeleteFile(carpeta + info.Name);
      Writeln(info.Name);
      Inc(res);
    until FindNext(info) <> 0;
  end;
  FindClose(Info);
  Result := res;
end;

procedure calcularTamaniosTablas(altoDisponible, anchoDisponible: integer;
  ajustarATamaniosCeldasPorDefecto: boolean);
const
  defaultColWidths = 64;
  defaultLineWidth = 1;
  nLineasBordes = 4;
  nPxLineasBordes = nLineasBordes * defaultLineWidth;
  auxWidth = defaultColWidths + defaultLineWidth;
begin
  CP_MAXANCHOTABLACHICA := round(anchoDisponible * 0.15);
  CP_MAXANCHOTABLAMEDIANA := round(anchoDisponible * 0.4);
  CP_maxAnchoTablaGrande := round(anchoDisponible * 0.6);
  CP_maxAnchoTablaMuyGrande := round(anchoDisponible * 0.75);
  CP_maxAnchoTablaEnorme := round(anchoDisponible * 0.95);

  CP_maxAlturaTablaChica := round(altoDisponible * 0.15);
  CP_maxAlturaTablaMediana := round(altoDisponible * 0.4);
  CP_maxAlturaTablaGrande := round(altoDisponible * 0.55);
  CP_maxAlturaTablaMuyGrande := round(altoDisponible * 0.75);
  CP_maxAlturaTablaEnorme := round(altoDisponible * 0.95);

  if ajustarATamaniosCeldasPorDefecto then
  begin
    //El alto de las filas de una tabla es 24 por defecto, por cada fila hay un
    //pixel mas de la linea separadora y uno mas al final por una linea extra
    //buscamos el primer multiplo de 25 + 1 para cada tamanio
    CP_MAXANCHOTABLACHICA := ((CP_MAXANCHOTABLACHICA div auxWidth) + 1) *
      auxWidth + nPxLineasBordes;
    CP_MAXANCHOTABLAMEDIANA :=
      ((CP_MAXANCHOTABLAMEDIANA div auxWidth) + 1) * auxWidth + nPxLineasBordes;
    CP_maxAnchoTablaGrande := ((CP_maxAnchoTablaGrande div auxWidth) + 1) *
      auxWidth + nPxLineasBordes;
    CP_maxAnchoTablaMuyGrande :=
      ((CP_maxAnchoTablaMuyGrande div auxWidth) + 1) * auxWidth + nPxLineasBordes;
    CP_maxAnchoTablaEnorme := ((CP_maxAnchoTablaEnorme div auxWidth) + 1) *
      auxWidth + nPxLineasBordes;

    CP_maxAlturaTablaChica := ((CP_maxAlturaTablaChica div auxWidth) + 1) *
      auxWidth + nPxLineasBordes;
    CP_maxAlturaTablaMediana :=
      ((CP_maxAlturaTablaMediana div auxWidth) + 1) * auxWidth + nPxLineasBordes;
    CP_maxAlturaTablaGrande :=
      ((CP_maxAlturaTablaGrande div auxWidth) + 1) * auxWidth + nPxLineasBordes;
    CP_maxAlturaTablaMuyGrande :=
      ((CP_maxAlturaTablaMuyGrande div auxWidth) + 1) * auxWidth + nPxLineasBordes;
    CP_maxAlturaTablaEnorme :=
      ((CP_maxAlturaTablaEnorme div auxWidth) + 1) * auxWidth + nPxLineasBordes;
  end;
end;

function getDefault_tmp_base_OLD_: string;
begin
{$IFDEF LINUX}
 {$IFDEF CLUSTER_UY}
  Result := '/scratch/' + GetEnvironmentVariable('USER');
 {$ELSE}
  Result := '/tmp/simsee_' + GetEnvironmentVariable('USER');
  //   home:= GetEnvironmentVariable( 'HOME' );
  {$ENDIF}
{$ELSE}
  Result := '\simsee\tmp_rundir';
{$ENDIF}
end;


function getDefault_tmp_base: string;
var
  archicfg: string;
  f: textfile;
  res: string;

function test( var res: string ): boolean;
begin
  if ( res <> '' )  then
  begin
    if DirectoryExists( res ) then
        result:= true
    else
       if CreateDir( res ) then
         result:= true
       else
       begin
         res:= '';
         result:= false;
       end;
  end
  else
    result:= false;
end;

begin
  res:= '';
  archicfg:= getDir_Bin + 'tmp_base.cfg';
  if FileExists( archicfg ) then
  begin
    filemode:= 0;
    assignfile( f, archicfg );
    reset( f );
    readln( f, res );
    res:= trim( res );
    closefile( f );
  end;


  if res <> '' then
  begin
    result:= res;
    exit;
  end;

 {$IFDEF LINUX}
 // Si estamos en linux intentamos ver si estamos en el CLUSTER_UY
 if DirectoryExists( '/scratch' ) then
 begin
   res:=  '/scratch/simsee_' + GetEnvironmentVariable('USER');
   if test( res ) then
   begin
     // lo guardo en al configuración para la siguiente vez
     assignfile( f, archicfg );
     filemode:= 1;
     rewrite( f );
     writeln( f, res );
     closefile( f );
   end
 end;
 if res = '' then
   res  := '/tmp/simsee_' + GetEnvironmentVariable('USER');
  //   home:= GetEnvironmentVariable( 'HOME' );
{$ELSE}
  Res := '\SimSEE\tmp_rundir';
{$ENDIF}
  result:= res;
end;


function CrearDirectorioTemporal(tmp_base, idEjecutor: string;
  idSubCarpetaSalida: string): string;
var
  tmp_rundir: string;
begin
  tmp_rundir := '';

  if length(tmp_base) > 0 then
    if tmp_base[length(tmp_base)] = DirectorySeparator then
      Delete(tmp_base, length(tmp_base), 1);

  if not DirectoryExists(tmp_base) then
    if not CreateDir(tmp_base) then
    begin
      writeln('Imposible crear directorio tmp_base: ', tmp_base);
      Result := '';
      exit;
    end;

  if idEjecutor <> '' then
  begin
    tmp_rundir := tmp_base + DirectorySeparator + idEjecutor;
    if not DirectoryExists(tmp_rundir) then
      if not CreateDir(tmp_rundir) then
      begin
        writeln('Imposible crear directorio ejecutor: ', tmp_rundir);
        Result := '';
      end;
  end
  else
    tmp_rundir := tmp_base;

  if idSubCarpetaSalida <> '' then
  begin
    tmp_rundir := tmp_rundir + DirectorySeparator + idSubCarpetaSalida;
    if not DirectoryExists(tmp_rundir) then
      if not CreateDir(tmp_rundir) then
      begin
        writeln('Imposible crear directorio idSubcarpeta: ', tmp_rundir);
        Result := '';
      end;
  end;
  Result := tmp_rundir;

end;


procedure crearDirectorios;
begin
  {$IFDEF CursoRuben}
  dirSala:='';
  {$ENDIF}
  if not DirectoryExists(getDir_Dbg) then
    CreateDir(getDir_Dbg);
  if not DirectoryExists(getDir_Run) then
    CreateDir(getDir_Run);
{$IFNDEF AYUDAENWEB}
  if not DirectoryExists(getDir_Docs) then
    CreateDir(getDir_Docs);
{$ENDIF}
  if not DirectoryExists(getDir_Lib) then
    CreateDir(getDir_Lib);
  if not DirectoryExists(getDir_Dbg) then
    CreateDir(getDir_Dbg);
  if not DirectoryExists(getDir_DatosComunes) then
    CreateDir(getDir_DatosComunes);
  if not DirectoryExists(getDir_Corridas) then
    CreateDir(getDir_Corridas);
  if not DirectoryExists(getDir_Tmp) then
    CreateDir(getDir_Tmp);
  if not DirectoryExists(getDir_CacheNube) then
    CreateDir(getDir_CacheNube);
end;


function quitarExtension(archi: string): string;
var
  ext: string;
  res: string;
begin
  ext := ExtractFileExt(Archi);
  res := copy(archi, 1, length(Archi) - length(ext));
  Result := res;
end;

procedure backupearArchivoAntesDeSalvar(nomArchivo: string; maxNBackups: integer);
var
  path, nombreSinExt, ext, nomArchivoBackup, base: string;
  i, iArchivoMinFecha: integer;
  fechaArchivo, minFechaArchivo: TDateTime;
{$IFDEF FPC}
  fechaArchivoSistema: longint;
{$ENDIF}
begin
  path := ExtractFilePath(nomArchivo);
  nombreSinExt := nombreArchSinExtension(nomArchivo);
  ext := ExtractFileExt(nomArchivo);
  base := path + 'backups' + DirectorySeparator;
  if not DirectoryExists(base) then
  begin
    MkDir(base);
    nomArchivoBackup := base + nombreSinExt + '_bk1' + ext;
  end
  else
  begin
    iArchivoMinFecha := -1;
    minFechaArchivo := EncodeDate(9999, 1, 1);
    base := base + nombreSinExt + '_bk';
    //Busco si hay un backup numerado entre 1 y maxNBackups sin crear
    i := 0;
    while (i < maxNBackups) and FileExists(nomArchivoBackup) do
      //esto antes era un repeat 25/4/11
    begin
      i := i + 1;
      nomArchivoBackup := base + IntToStr(i) + ext;
      {$IFNDEF FPC}
      FileAge(nomArchivoBackup, fechaArchivo);
      {$ELSE}
      fechaArchivoSistema := FileAge(nomArchivoBackup); { *Converted from FileAge*  }
      fechaArchivo := FileDateTodateTime(fechaArchivoSistema);
      {$ENDIF}
      if fechaArchivo < minFechaArchivo then
      begin
        minFechaArchivo := fechaArchivo;
        iArchivoMinFecha := i;
      end;
    end;

    //Si ya estan todos creados remplazo el mas viejo
    if (i = maxNBackups) and FileExists(nomArchivoBackup)
    { *Converted from FileExists*  } then
      nomArchivoBackup := base + IntToStr(iArchivoMinFecha) + ext;
  end;
  RenameFile(nomArchivo, nomArchivoBackup); { *Converted from RenameFile*  }
  FileSetDate(nomArchivoBackup, DateTimeToFileDate(now));
  { *Converted from FileSetDate*  }
end;

function getDir_SimSEE: string;
var
  res: string;
begin
  res := getDir_Bin;
  subirDirectorio(res);
  Result := res;
end;

function getDir_Bin: string;
begin
  Result := ExtractFileDir(ParamStr(0)) + DirectorySeparator;
end;

function nombreArchSinExtension(const nomArch: string): string;
var
  posUltimoPunto, posUltimaBarraDir: integer;
begin
  posUltimoPunto := Length(nomArch) - 1;
  while (posUltimoPunto > 0) and (nomArch[posUltimoPunto] <> '.') do
    posUltimoPunto := posUltimoPunto - 1;


  if posUltimoPunto > 0 then
    posUltimaBarraDir := posUltimoPunto - 1
  else
    posUltimaBarraDir := Length(nomArch) - 1;

  while (posUltimaBarraDir > 0) and (nomArch[posUltimaBarraDir] <> DirectorySeparator) do
    posUltimaBarraDir := posUltimaBarraDir - 1;

  if posUltimoPunto > 0 then
    Result := copy(nomArch, posUltimaBarraDir + 1, posUltimoPunto -
      (posUltimaBarraDir + 1))
  else
    Result := Copy(nomArch, posUltimaBarraDir + 1, length(nomArch) - posUltimaBarraDir);
end;

function getCurrentDrive: string;
var
  s1: string;
begin
  s1 := '';
  GetDir(0, s1);
  Result := Copy(s1, 0, 2);
end;

{$IFDEF LINUX}
//Si el archivo path existe lo deja sin modificar, sino le quita la raiz y lo
//cambia por '/home/topo/' + toOSBarraDirs(path)
procedure toLinuxDir(var path: string);
var
  ruta, arch: string;
  homeDir: string;
begin
  if path <> '' then
  begin
    toOSBarraDirs(path);
    if not FileExists(path) then
    begin
      ruta := LowerCase(ExtractFilePath(path));
      arch := ExtractFileName(path);
      homeDir := GetEnvironmentVariable('HOME');
      if homeDir = '' then
        homeDir := '/home/topo';
      if path[1] = DirectorySeparator then
        path := homeDir + ruta + arch
      else
        path := homeDir + DirectorySeparator + ruta + arch;
    end;
  end;
end;

{$ENDIF}

function getDir_Dbg: string;
var
  res: string;
begin
  if tmp_rundir = '' then
  begin
    res := getDir_Bin;
    subirDirectorio(res);
    res := res + 'debug' + DirectorySeparator;
  end
  else
  if tmp_rundir[length(tmp_rundir)] = DirectorySeparator then
    res := tmp_rundir
  else
    res := tmp_rundir + DirectorySeparator;
  Result := res;
end;

function getDir_Run: string;
var
  res: string;
begin
  if tmp_rundir = '' then
  begin
    res := getDir_Bin;
    subirDirectorio(res);
    res := res + 'rundir' + DirectorySeparator;
  end
  else
  if tmp_rundir[length(tmp_rundir)] = DirectorySeparator then
    res := tmp_rundir
  else
    res := tmp_rundir + DirectorySeparator;
  Result := res;
end;

function getDir_Tmp: string;
var
  res: string;
begin

  {$IFDEF CursoRuben}
  if dirSala='' then
  begin
    if tmp_rundir = '' then
    begin
      res := getDir_Bin;
      subirDirectorio(res);
      res := res + 'tmp' + DirectorySeparator;
    end
    else
    if tmp_rundir[length(tmp_rundir)] = DirectorySeparator then
      res := tmp_rundir
    else
      res := tmp_rundir + DirectorySeparator;
  end
  else
  begin
    if dirSala[Length(dirSala)] = DirectorySeparator then
      res :=dirSala + 'tmp' + DirectorySeparator
    else
      res :=dirSala + DirectorySeparator+ 'tmp' + DirectorySeparator ;
    if not DirectoryExists(res) then
       CreateDir(res);
  end;
  {$ELSE}
  if tmp_rundir = '' then
  begin
    res := getDir_Bin;
    subirDirectorio(res);
    res := res + 'tmp' + DirectorySeparator;
  end
  else
  if tmp_rundir[length(tmp_rundir)] = DirectorySeparator then
    res := tmp_rundir
  else
    res := tmp_rundir + DirectorySeparator;
  {$ENDIF}


  Result := res;
end;

function getDir_CacheNube: string;
var
  res: string;
begin
  res := getDir_Bin;
  subirDirectorio(res);
  Result := res + 'cache_nube' + DirectorySeparator;
end;

function getDir_CacheOddFace: string;
begin
  Result := getDir_SimSEE + 'cache_oddface';
end;

function getDir_SimSEE_ws: string;
begin
  Result := getDir_SimSEE + 'ws';
end;


function getDir_Docs: string;
{$IFNDEF AYUDAENWEB}
var
  res: string;
{$ENDIF}
begin
{$IFNDEF AYUDAENWEB}
  res := getDir_Bin;
  subirDirectorio(res);
  Result := res + 'docs-word' + DirectorySeparator;
{$ELSE}
  Result := 'http://iie.fing.edu.uy/simsee/simsee/ayuda/';
{$ENDIF}
end;

function getDir_Lib: string;
var
  res: string;
begin
  res := getDir_Bin;
  subirDirectorio(res);
  Result := res + 'librerias' + DirectorySeparator;
end;

function getDir_DatosComunes: string;
var
  res: string;
begin
  res := getDir_Bin;
  subirDirectorio(res);
  Result := res + 'datos_comunes' + DirectorySeparator;
end;

function getDir_Corridas: string;
var
  res: string;
begin
  res := getDir_Bin;
  subirDirectorio(res);
  Result := res + 'corridas' + DirectorySeparator;
end;

function get_cv_falla: double;
begin
  Result := 10000; //10 mil
end;

{$IFNDEF APLICACION_CONSOLA}
procedure initConstantesTamanio;
begin
  if screen <> nil then
  begin
    base_ScreenWidth := Screen.WorkAreaWidth;
    base_ScreenHeight := Screen.WorkAreaHeight;
  end
  else
  begin
    base_ScreenWidth := 800;
    base_ScreenHeight := 600;
  end;
  calcularTamaniosTablas(base_ScreenHeight, base_ScreenWidth, True);
end;


{$ENDIF}
initialization

{$IFDEF CursoRuben}
dirSala:='';
{$ENDIF}

{$IFNDEF APLICACION_CONSOLA}
  initConstantesTamanio;

{$ENDIF}


end.
