*** empty log message ***

Common/CreateFile.cpp

+// $Id: CreateFile.cpp,v 1.1 2008-07-04 15:02:47 geuzaine Exp $
+//
+// Copyright (C) 1997-2008 C. Geuzaine, J.-F. Remacle
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+// 
+// Please report all bugs and problems to <gmsh@geuz.org>.
+
+#include <string.h>
+#include "Message.h"
+#include "GModel.h"
+#include "GmshDefines.h"
+#include "StringUtils.h"
+#include "Context.h"
+#include "Options.h"
+
+#if defined(HAVE_FLTK)
+#include "GmshUI.h"
+#include "gl2ps.h"
+#include "gl2gif.h"
+#include "gl2jpeg.h"
+#include "gl2png.h"
+#include "gl2ppm.h"
+#include "gl2yuv.h"
+#endif
+
+extern Context_T CTX;
+
+int GuessFileFormatFromFileName(const char *name)
+{
+  int len;
+  char ext[256];
+
+  for(len = strlen(name) - 1; len >= 0; len--) {
+    if(name[len] == '.') {
+      strcpy(ext, &name[len]);
+      break;
+    }
+  }
+  if(len <= 0)
+    strcpy(ext, "");
+  
+  if     (!strcmp(ext, ".geo"))  return FORMAT_GEO;
+  else if(!strcmp(ext, ".msh"))  return FORMAT_MSH;
+  else if(!strcmp(ext, ".pos"))  return FORMAT_POS;
+  else if(!strcmp(ext, ".opt"))  return FORMAT_OPT;
+  else if(!strcmp(ext, ".unv"))  return FORMAT_UNV;
+  else if(!strcmp(ext, ".vtk"))  return FORMAT_VTK;
+  else if(!strcmp(ext, ".stl"))  return FORMAT_STL;
+  else if(!strcmp(ext, ".cgns")) return FORMAT_CGNS;
+  else if(!strcmp(ext, ".med"))  return FORMAT_MED;
+  else if(!strcmp(ext, ".mesh")) return FORMAT_MESH;
+  else if(!strcmp(ext, ".bdf"))  return FORMAT_BDF;
+  else if(!strcmp(ext, ".nas"))  return FORMAT_BDF;
+  else if(!strcmp(ext, ".p3d"))  return FORMAT_P3D;
+  else if(!strcmp(ext, ".wrl"))  return FORMAT_VRML;
+  else if(!strcmp(ext, ".vrml")) return FORMAT_VRML;
+  else if(!strcmp(ext, ".gif"))  return FORMAT_GIF;
+  else if(!strcmp(ext, ".jpg"))  return FORMAT_JPEG;
+  else if(!strcmp(ext, ".jpeg")) return FORMAT_JPEG;
+  else if(!strcmp(ext, ".png"))  return FORMAT_PNG;
+  else if(!strcmp(ext, ".ps"))   return FORMAT_PS;
+  else if(!strcmp(ext, ".eps"))  return FORMAT_EPS;
+  else if(!strcmp(ext, ".pdf"))  return FORMAT_PDF;
+  else if(!strcmp(ext, ".tex"))  return FORMAT_TEX;
+  else if(!strcmp(ext, ".svg"))  return FORMAT_SVG;
+  else if(!strcmp(ext, ".ppm"))  return FORMAT_PPM;
+  else if(!strcmp(ext, ".yuv"))  return FORMAT_YUV;
+  else                           return -1;
+}
+
+void GetDefaultFileName(int format, char *name)
+{
+  char ext[32] = "";
+  strcpy(name, CTX.no_ext_filename);
+  switch(format){
+  case FORMAT_GEO:  strcpy(ext, ".geo_unrolled"); break;
+  case FORMAT_MSH:  strcpy(ext, ".msh"); break;
+  case FORMAT_POS:  strcpy(ext, ".pos"); break;
+  case FORMAT_OPT:  strcpy(ext, ".opt"); break;
+  case FORMAT_UNV:  strcpy(ext, ".unv"); break;
+  case FORMAT_VTK:  strcpy(ext, ".vtk"); break;
+  case FORMAT_STL:  strcpy(ext, ".stl"); break;
+  case FORMAT_CGNS: strcpy(ext, ".cgns"); break;
+  case FORMAT_MED:  strcpy(ext, ".med"); break;
+  case FORMAT_MESH: strcpy(ext, ".mesh"); break;
+  case FORMAT_BDF:  strcpy(ext, ".bdf"); break;
+  case FORMAT_P3D:  strcpy(ext, ".p3d"); break;
+  case FORMAT_VRML: strcpy(ext, ".wrl"); break;
+  case FORMAT_GIF:  strcpy(ext, ".gif"); break;
+  case FORMAT_JPEG: strcpy(ext, ".jpg"); break;
+  case FORMAT_PNG:  strcpy(ext, ".png"); break;
+  case FORMAT_PS:   strcpy(ext, ".ps"); break;
+  case FORMAT_EPS:  strcpy(ext, ".eps"); break;
+  case FORMAT_PDF:  strcpy(ext, ".pdf"); break;
+  case FORMAT_TEX:  strcpy(ext, ".tex"); break;
+  case FORMAT_SVG:  strcpy(ext, ".svg"); break;
+  case FORMAT_PPM:  strcpy(ext, ".ppm"); break;
+  case FORMAT_YUV:  strcpy(ext, ".yuv"); break;
+  default: break;
+  }
+  strcat(name, ext);
+}
+
+void CreateOutputFile(const char *filename, int format)
+{
+  char name[256], no_ext[256], ext[256], base[256];
+
+  if(!filename || !strlen(filename))
+    GetDefaultFileName(format, name);
+  else
+    strcpy(name, filename);
+
+  splitFileName(name, no_ext, ext, base);
+
+  int oldformat = CTX.print.format;
+  CTX.print.format = format;
+  CTX.printing = 1;
+
+#if defined(HAVE_FLTK)
+  GLint viewport[4];
+  for(int i = 0; i < 4; i++) viewport[i] = CTX.viewport[i];
+  GLint width = viewport[2] - viewport[0];
+  GLint height = viewport[3] - viewport[1];
+#endif
+
+  bool printEndMessage = true;
+  if(format != FORMAT_AUTO) Msg::StatusBar(2, true, "Writing '%s'", name);
+
+  switch (format) {
+
+  case FORMAT_AUTO:
+    CreateOutputFile(name, GuessFileFormatFromFileName(name));
+    printEndMessage = false;
+    break;
+    
+  case FORMAT_OPT:
+    Print_Options(0, GMSH_FULLRC, 1, 1, name);
+    break;
+
+  case FORMAT_MSH:
+    GModel::current()->writeMSH(name, CTX.mesh.msh_file_version, CTX.mesh.msh_binary, 
+                                CTX.mesh.save_all, CTX.mesh.scaling_factor);
+    break;
+
+  case FORMAT_STL:
+    GModel::current()->writeSTL(name, CTX.mesh.stl_binary,
+                                CTX.mesh.save_all, CTX.mesh.scaling_factor);
+    break;
+
+  case FORMAT_VRML:
+    GModel::current()->writeVRML(name, CTX.mesh.save_all, CTX.mesh.scaling_factor);
+    break;
+
+  case FORMAT_UNV:
+    GModel::current()->writeUNV(name, CTX.mesh.save_all, CTX.mesh.save_groups_of_nodes,
+                                CTX.mesh.scaling_factor);
+    break;
+
+  case FORMAT_VTK:
+    GModel::current()->writeVTK(name, CTX.mesh.msh_binary, CTX.mesh.save_all,
+                                CTX.mesh.scaling_factor);
+    break;
+
+  case FORMAT_MESH:
+    GModel::current()->writeMESH(name, CTX.mesh.save_all, CTX.mesh.scaling_factor);
+    break;
+
+  case FORMAT_BDF:
+    GModel::current()->writeBDF(name, CTX.mesh.bdf_field_format, 
+                     CTX.mesh.save_all, CTX.mesh.scaling_factor);
+    break;
+
+  case FORMAT_P3D:
+    GModel::current()->writeP3D(name, CTX.mesh.save_all, CTX.mesh.scaling_factor);
+    break;
+
+  case FORMAT_CGNS:
+    GModel::current()->writeCGNS(name, CTX.mesh.scaling_factor);
+    break;
+
+  case FORMAT_MED:
+    GModel::current()->writeMED(name, CTX.mesh.save_all, CTX.mesh.scaling_factor);
+    break;
+
+  case FORMAT_POS:
+    GModel::current()->writePOS(name, CTX.print.pos_elementary, CTX.print.pos_element, 
+                                CTX.print.pos_gamma, CTX.print.pos_eta, CTX.print.pos_rho, 
+                                CTX.mesh.save_all, CTX.mesh.scaling_factor);
+    break;
+
+  case FORMAT_GEO:
+    GModel::current()->writeGEO(name, CTX.print.geo_labels);
+    break;
+
+#if defined(HAVE_FLTK)
+  case FORMAT_PPM:
+  case FORMAT_YUV:
+  case FORMAT_GIF:  
+  case FORMAT_JPEG:
+  case FORMAT_PNG:
+    {
+      FILE *fp;
+      if(!(fp = fopen(name, "wb"))) {
+        Msg::Error("Unable to open file '%s'", name);
+        break;
+      }
+
+      PixelBuffer buffer(width, height, GL_RGB, GL_UNSIGNED_BYTE);
+
+      int old_bg_gradient = CTX.bg_gradient;
+      if(format == FORMAT_GIF && CTX.print.gif_transparent)
+        CTX.bg_gradient = 0;
+      buffer.Fill(CTX.batch);
+      CTX.bg_gradient = old_bg_gradient;
+
+      if(format == FORMAT_PPM){
+        create_ppm(fp, &buffer);
+      }
+      else if(format == FORMAT_YUV){
+        create_yuv(fp, &buffer);
+      }
+      else if(format == FORMAT_GIF){
+        create_gif(fp, &buffer,
+                   CTX.print.gif_dither,
+                   CTX.print.gif_sort,
+                   CTX.print.gif_interlace,
+                   CTX.print.gif_transparent,
+                   CTX.UNPACK_RED(CTX.color.bg),
+                   CTX.UNPACK_GREEN(CTX.color.bg), 
+                   CTX.UNPACK_BLUE(CTX.color.bg));
+      }
+      else if(format == FORMAT_JPEG){
+        create_jpeg(fp, &buffer, CTX.print.jpeg_quality, CTX.print.jpeg_smoothing);
+      }
+      else{
+        create_png(fp, &buffer, 100);
+      }
+      fclose(fp);
+    }
+    break;
+
+  case FORMAT_PS:
+  case FORMAT_EPS:
+  case FORMAT_PDF:
+  case FORMAT_SVG:
+    {
+      FILE *fp;
+      if(!(fp = fopen(name, "wb"))) {
+        Msg::Error("Unable to open file '%s'", name);
+        break;
+      }
+      
+      int psformat;
+      switch(format){
+      case FORMAT_PDF:
+        psformat = GL2PS_PDF;
+        break;
+      case FORMAT_PS:
+        psformat = GL2PS_PS;
+        break;
+      case FORMAT_SVG:
+        psformat = GL2PS_SVG;
+        break;
+      default:
+        psformat = GL2PS_EPS;
+        break;
+      }
+
+      int old_bg_gradient = CTX.bg_gradient;
+      if(!CTX.print.eps_background) CTX.bg_gradient = 0;
+      
+      PixelBuffer buffer(width, height, GL_RGB, GL_FLOAT);
+      
+      if(CTX.print.eps_quality == 0)
+        buffer.Fill(CTX.batch);
+      
+      int pssort = 
+        (CTX.print.eps_quality == 3) ? GL2PS_NO_SORT :
+        (CTX.print.eps_quality == 2) ? GL2PS_BSP_SORT : 
+        GL2PS_SIMPLE_SORT;
+      int psoptions =
+        GL2PS_SIMPLE_LINE_OFFSET | GL2PS_SILENT |
+        (CTX.print.eps_occlusion_culling ? GL2PS_OCCLUSION_CULL : 0) |
+        (CTX.print.eps_best_root ? GL2PS_BEST_ROOT : 0) |
+        (CTX.print.eps_background ? GL2PS_DRAW_BACKGROUND : 0) |
+        (CTX.print.eps_compress ? GL2PS_COMPRESS : 0) |
+        (CTX.print.eps_ps3shading ? 0 : GL2PS_NO_PS3_SHADING);
+
+      GLint buffsize = 0;
+      int res = GL2PS_OVERFLOW;
+      while(res == GL2PS_OVERFLOW) {
+        buffsize += 2048 * 2048;
+        gl2psBeginPage(CTX.base_filename, "Gmsh", viewport, 
+                       psformat, pssort, psoptions, GL_RGBA, 0, NULL, 
+                       15, 20, 10, buffsize, fp, base);
+        if(CTX.print.eps_quality == 0){
+          double modelview[16], projection[16];
+          glGetDoublev(GL_PROJECTION_MATRIX, projection);
+          glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
+          glMatrixMode(GL_PROJECTION);
+          glLoadIdentity();
+          glOrtho((double)CTX.viewport[0], (double)CTX.viewport[2],
+                  (double)CTX.viewport[1], (double)CTX.viewport[3], -1., 1.);
+          glMatrixMode(GL_MODELVIEW);
+          glLoadIdentity();
+          glRasterPos2d(0, 0);
+          gl2psDrawPixels(width, height, 0, 0, GL_RGB, GL_FLOAT, buffer.GetPixels());
+          glMatrixMode(GL_PROJECTION);
+          glLoadMatrixd(projection);
+          glMatrixMode(GL_MODELVIEW);
+          glLoadMatrixd(modelview);
+        }
+        else{
+          buffer.Fill(CTX.batch);
+        }
+        res = gl2psEndPage();
+      }
+
+      CTX.bg_gradient = old_bg_gradient;
+      fclose(fp);
+    }
+    break;
+
+  case FORMAT_TEX:
+    {
+      FILE *fp;
+      if(!(fp = fopen(name, "w"))) {
+        Msg::Error("Unable to open file '%s'", name);
+        break;
+      }
+      GLint buffsize = 0;
+      int res = GL2PS_OVERFLOW;
+      while(res == GL2PS_OVERFLOW) {
+        buffsize += 2048 * 2048;
+        gl2psBeginPage(CTX.base_filename, "Gmsh", viewport,
+                       GL2PS_TEX, GL2PS_NO_SORT, GL2PS_NONE, GL_RGBA, 0, NULL, 
+                       0, 0, 0, buffsize, fp, base);
+        PixelBuffer buffer(width, height, GL_RGB, GL_UNSIGNED_BYTE);
+        int oldtext = CTX.print.text;
+        CTX.print.text = 1;
+        buffer.Fill(CTX.batch);
+        CTX.print.text = oldtext;
+        res = gl2psEndPage();
+      }
+      fclose(fp);
+    }
+    break;
+#endif
+
+  default:
+    Msg::Error("Unknown output file format");
+    printEndMessage = false;
+    break;
+  }
+
+  if(printEndMessage) Msg::StatusBar(2, true, "Wrote '%s'", name);
+
+  CTX.print.format = oldformat;
+  CTX.printing = 0;
+
+#if defined(HAVE_FLTK)
+  Draw();
+#endif
+}

Common/CreateFile.h

+#ifndef _CREATE_FILE_H_
+#define _CREATE_FILE_H_
+
+// Copyright (C) 1997-2008 C. Geuzaine, J.-F. Remacle
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+// 
+// Please report all bugs and problems to <gmsh@geuz.org>.
+
+int GuessFileFormatFromFileName(const char *name);
+void GetDefaultFileName(int format, char *name);
+void CreateOutputFile(const char *name, int format);
+
+#endif

Common/OpenFile.cpp

+// $Id: OpenFile.cpp,v 1.1 2008-07-04 15:02:47 geuzaine Exp $
+//
+// Copyright (C) 1997-2008 C. Geuzaine, J.-F. Remacle
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+// 
+// Please report all bugs and problems to <gmsh@geuz.org>.
+
+#include <string.h>
+#include "Message.h"
+#include "Geo.h"
+#include "GModel.h"
+#include "Numeric.h"
+#include "Context.h"
+#include "OpenFile.h"
+#include "CommandLine.h"
+#include "ReadImg.h"
+#include "OS.h"
+#include "StringUtils.h"
+
+#if !defined(HAVE_NO_PARSER)
+#include "Parser.h"
+#endif
+
+#if !defined(HAVE_NO_POST)
+#include "PView.h"
+#include "PViewData.h"
+#endif
+
+#if defined(HAVE_FLTK)
+#include "GmshUI.h"
+#include "Draw.h"
+#include "SelectBuffer.h"
+#include "GUI.h"
+extern GUI *WID;
+#endif
+
+extern Context_T CTX;
+
+static void FinishUpBoundingBox()
+{
+  double range[3];
+
+  for(int i = 0; i < 3; i++){
+    CTX.cg[i] = 0.5 * (CTX.min[i] + CTX.max[i]);
+    range[i] = CTX.max[i] - CTX.min[i];
+  }
+
+  if(range[0] < CTX.geom.tolerance && 
+     range[1] < CTX.geom.tolerance && 
+     range[2] < CTX.geom.tolerance) {
+    CTX.min[0] -= 1.; CTX.min[1] -= 1.;
+    CTX.max[0] += 1.; CTX.max[1] += 1.;
+    CTX.lc = 1.;
+  }
+  else if(range[0] < CTX.geom.tolerance && 
+          range[1] < CTX.geom.tolerance) {
+    CTX.lc = range[2];
+    CTX.min[0] -= CTX.lc; CTX.min[1] -= CTX.lc;
+    CTX.max[0] += CTX.lc; CTX.max[1] += CTX.lc;
+  }
+  else if(range[0] < CTX.geom.tolerance && 
+          range[2] < CTX.geom.tolerance) {
+    CTX.lc = range[1];
+    CTX.min[0] -= CTX.lc; CTX.max[0] += CTX.lc;
+  }
+  else if(range[1] < CTX.geom.tolerance && 
+          range[2] < CTX.geom.tolerance) {
+    CTX.lc = range[0];
+    CTX.min[1] -= CTX.lc; CTX.max[1] += CTX.lc;
+  }
+  else if(range[0] < CTX.geom.tolerance) {
+    CTX.lc = sqrt(DSQR(range[1]) + DSQR(range[2]));
+    CTX.min[0] -= CTX.lc; CTX.max[0] += CTX.lc;
+  }
+  else if(range[1] < CTX.geom.tolerance) {
+    CTX.lc = sqrt(DSQR(range[0]) + DSQR(range[2]));
+    CTX.min[1] -= CTX.lc; CTX.max[1] += CTX.lc;
+  }
+  else if(range[2] < CTX.geom.tolerance) {
+    CTX.lc = sqrt(DSQR(range[0]) + DSQR(range[1]));
+  }
+  else {
+    CTX.lc = sqrt(DSQR(range[0]) + DSQR(range[1]) + DSQR(range[2]));
+  }
+}
+
+void SetBoundingBox(double xmin, double xmax,
+                    double ymin, double ymax, 
+                    double zmin, double zmax)
+{
+  CTX.min[0] = xmin; CTX.max[0] = xmax;
+  CTX.min[1] = ymin; CTX.max[1] = ymax;
+  CTX.min[2] = zmin; CTX.max[2] = zmax;
+  FinishUpBoundingBox();
+}
+
+void SetBoundingBox()
+{
+  if(CTX.forced_bbox) return;
+
+  SBoundingBox3d bb = GModel::current()->bounds();
+  
+#if !defined(HAVE_NO_POST)
+  if(bb.empty()) {
+    for(unsigned int i = 0; i < PView::list.size(); i++)
+      if(!PView::list[i]->getData()->getBoundingBox().empty())
+        bb += PView::list[i]->getData()->getBoundingBox();
+  }
+#endif
+  
+  if(bb.empty()){
+    bb += SPoint3(-1., -1., -1.);
+    bb += SPoint3(1., 1., 1.);
+  }
+  
+  CTX.min[0] = bb.min().x(); CTX.max[0] = bb.max().x();
+  CTX.min[1] = bb.min().y(); CTX.max[1] = bb.max().y();
+  CTX.min[2] = bb.min().z(); CTX.max[2] = bb.max().z();
+  FinishUpBoundingBox();
+}
+
+// FIXME: this is necessary for now to have an approximate CTX.lc
+// *while* parsing input files (it's important since some of the
+// geometrical operations use a tolerance that depends on
+// CTX.lc). This will be removed once the new database is filled
+// directly during the parsing step
+static SBoundingBox3d temp_bb;
+
+void ResetTemporaryBoundingBox()
+{
+  temp_bb.reset();
+}
+
+void AddToTemporaryBoundingBox(double x, double y, double z)
+{
+  temp_bb += SPoint3(x, y, z);
+  CTX.min[0] = temp_bb.min().x(); CTX.max[0] = temp_bb.max().x();
+  CTX.min[1] = temp_bb.min().y(); CTX.max[1] = temp_bb.max().y();
+  CTX.min[2] = temp_bb.min().z(); CTX.max[2] = temp_bb.max().z();
+  FinishUpBoundingBox();
+}
+
+int ParseFile(const char *f, int close, int warn_if_missing)
+{
+#if defined(HAVE_NO_PARSER)
+  Msg::Error("Gmsh parser is not compiled in this version");
+  return 0;
+#else
+  char yyname_old[256], tmp[256];
+  FILE *yyin_old, *fp;
+  int yylineno_old, yyerrorstate_old, yyviewindex_old;
+
+  // add 'b' for pure Windows programs: opening in text mode messes up
+  // fsetpos/fgetpos (used e.g. for user-defined functions)
+  if(!(fp = fopen(f, "rb"))){
+    if(warn_if_missing) Msg::Warning("Unable to open file '%s'", f);
+    return 0;
+  }
+
+#if !defined(HAVE_NO_POST)
+  int numViewsBefore = PView::list.size();
+#endif
+
+  strncpy(yyname_old, gmsh_yyname, 255);
+  yyin_old = gmsh_yyin;
+  yyerrorstate_old = gmsh_yyerrorstate;
+  yylineno_old = gmsh_yylineno;
+  yyviewindex_old = gmsh_yyviewindex;
+
+  strncpy(gmsh_yyname, f, 255);
+  gmsh_yyin = fp;
+  gmsh_yyerrorstate = 0;
+  gmsh_yylineno = 1;
+  gmsh_yyviewindex = 0;
+
+  fpos_t position;
+  fgetpos(gmsh_yyin, &position);
+  fgets(tmp, sizeof(tmp), gmsh_yyin);
+  fsetpos(gmsh_yyin, &position);
+
+  while(!feof(gmsh_yyin)){
+    gmsh_yyparse();
+    if(gmsh_yyerrorstate > 20){
+      Msg::Error("Too many errors: aborting...");
+      force_yyflush();
+      break;
+    }
+  }
+
+  if(close) fclose(gmsh_yyin);
+
+  strncpy(gmsh_yyname, yyname_old, 255);
+  gmsh_yyin = yyin_old;
+  gmsh_yyerrorstate = yyerrorstate_old;
+  gmsh_yylineno = yylineno_old;
+  gmsh_yyviewindex = yyviewindex_old;
+
+#if defined(HAVE_FLTK) && !defined(HAVE_NO_POST)
+  if(!CTX.batch && numViewsBefore != (int)PView::list.size())
+    WID->update_views();
+#endif
+
+  return 1;
+#endif
+}
+
+void ParseString(const char *str)
+{
+  if(!str) return;
+  FILE *fp;
+  if((fp = fopen(CTX.tmp_filename_fullpath, "w"))) {
+    fprintf(fp, str);
+    fprintf(fp, "\n");
+    fclose(fp);
+    ParseFile(CTX.tmp_filename_fullpath, 1);
+    GModel::current()->importGEOInternals();
+  }
+}
+
+void SetProjectName(const char *name)
+{
+  char no_ext[256], ext[256], base[256];
+  splitFileName(name, no_ext, ext, base);
+
+  if(CTX.filename != name) // yes, we mean to compare the pointers
+    strncpy(CTX.filename, name, 255);
+  strncpy(CTX.no_ext_filename, no_ext, 255);
+  strncpy(CTX.base_filename, base, 255);
+
+  GModel::current()->setName(base);
+    
+#if defined(HAVE_FLTK)
+  if(!CTX.batch) WID->set_title(CTX.filename);
+#endif
+}
+
+int MergeFile(const char *name, int warn_if_missing)
+{
+  // added 'b' for pure Windows programs, since some of these files
+  // contain binary data
+  FILE *fp = fopen(name, "rb");
+  if(!fp){
+    if(warn_if_missing) Msg::Warning("Unable to open file '%s'", name);
+    return 0;
+  }
+
+  char header[256];
+  fgets(header, sizeof(header), fp);
+  fclose(fp);
+
+  Msg::StatusBar(2, true, "Reading '%s'", name);
+
+  char no_ext[256], ext[256], base[256];
+  splitFileName(name, no_ext, ext, base);
+
+#if defined(HAVE_FLTK)
+  if(!CTX.batch) {
+    if(!strcmp(ext, ".gz")) {
+      // the real solution would be to rewrite all our I/O functions in
+      // terms of gzFile, but until then, this is better than nothing
+      if(fl_choice("File '%s' is in gzip format.\n\nDo you want to uncompress it?", 
+                   "Cancel", "Uncompress", NULL, name)){
+        char tmp[256];
+        sprintf(tmp, "gunzip -c %s > %s", name, no_ext);
+        if(SystemCall(tmp))
+          Msg::Error("Failed to uncompress `%s': check directory permissions", name);
+        if(!strcmp(CTX.filename, name)) // this is the project file
+          SetProjectName(no_ext);
+        return MergeFile(no_ext);
+      }
+    }
+  }
+#endif
+
+  CTX.geom.draw = 0; // don't try to draw the model while reading
+
+  GModel *m = GModel::current();
+
+  // FIXME: We need to decide what do do for CAD entities, meshes,
+  // etc.  For meshes we should definitely create one new model per
+  // merge (and reset current() to the previous value after the
+  // merge). This will make multi-step multi-meshes post-pro views
+  // work out of the box.
+  // GModel *m = new GModel;
+
+#if !defined(HAVE_NO_POST)
+  int numViewsBefore = PView::list.size();
+#endif
+
+  int status = 0;
+  if(!strcmp(ext, ".stl") || !strcmp(ext, ".STL")){
+    status = m->readSTL(name, CTX.geom.tolerance);
+  }
+  else if(!strcmp(ext, ".brep") || !strcmp(ext, ".rle") ||
+          !strcmp(ext, ".brp") || !strcmp(ext, ".BRP")){
+    status = m->readOCCBREP(std::string(name));
+  }
+  else if(!strcmp(ext, ".iges") || !strcmp(ext, ".IGES") ||
+          !strcmp(ext, ".igs") || !strcmp(ext, ".IGS")){
+    status = m->readOCCIGES(std::string(name));
+  }
+  else if(!strcmp(ext, ".step") || !strcmp(ext, ".STEP") ||
+          !strcmp(ext, ".stp") || !strcmp(ext, ".STP")){
+    status = m->readOCCSTEP(std::string(name));
+  }
+  else if(!strcmp(ext, ".unv") || !strcmp(ext, ".UNV")){
+    status = m->readUNV(name);
+  }
+  else if(!strcmp(ext, ".wrl") || !strcmp(ext, ".WRL") || 
+          !strcmp(ext, ".vrml") || !strcmp(ext, ".VRML") ||
+          !strcmp(ext, ".iv") || !strcmp(ext, ".IV")){
+    status = m->readVRML(name);
+  }
+  else if(!strcmp(ext, ".mesh") || !strcmp(ext, ".MESH")){
+    status = m->readMESH(name);
+  }
+#if !defined(HAVE_NO_POST)
+  else if(!strcmp(ext, ".med") || !strcmp(ext, ".MED") ||
+	  !strcmp(ext, ".mmed") || !strcmp(ext, ".MMED") ||
+	  !strcmp(ext, ".rmed") || !strcmp(ext, ".RMED")){
+    status = GModel::readMED(name);
+    if(status > 1) status = PView::readMED(name);
+  }
+#endif
+  else if(!strcmp(ext, ".bdf") || !strcmp(ext, ".BDF") ||
+          !strcmp(ext, ".nas") || !strcmp(ext, ".NAS")){
+    status = m->readBDF(name);
+  }
+  else if(!strcmp(ext, ".p3d") || !strcmp(ext, ".P3D")){
+    status = m->readP3D(name);
+  }
+  else if(!strcmp(ext, ".fm") || !strcmp(ext, ".FM")) {
+    status = m->readFourier(name);
+  }
+#if defined(HAVE_FLTK)
+  else if(!strcmp(ext, ".pnm") || !strcmp(ext, ".PNM") ||
+          !strcmp(ext, ".pbm") || !strcmp(ext, ".PBM") ||
+          !strcmp(ext, ".pgm") || !strcmp(ext, ".PGM") ||
+          !strcmp(ext, ".ppm") || !strcmp(ext, ".PPM")) {
+    status = read_pnm(name);
+  }
+  else if(!strcmp(ext, ".bmp") || !strcmp(ext, ".BMP")) {
+    status = read_bmp(name);
+  }
+#if defined(HAVE_LIBJPEG)
+  else if(!strcmp(ext, ".jpg") || !strcmp(ext, ".JPG") ||
+          !strcmp(ext, ".jpeg") || !strcmp(ext, ".JPEG")) {
+    status = read_jpeg(name);
+  }
+#endif
+#if defined(HAVE_LIBPNG)
+  else if(!strcmp(ext, ".png") || !strcmp(ext, ".PNG")) {
+    status = read_png(name);
+  }
+#endif
+#endif
+  else {
+    CTX.geom.draw = 1;
+    if(!strncmp(header, "$PTS", 4) || !strncmp(header, "$NO", 3) || 
+       !strncmp(header, "$PARA", 5) || !strncmp(header, "$ELM", 4) ||
+       !strncmp(header, "$MeshFormat", 11)) {
+      status = m->readMSH(name);
+#if !defined(HAVE_NO_POST)
+      if(status > 1) status = PView::readMSH(name);
+#endif
+    }
+#if !defined(HAVE_NO_POST)
+    else if(!strncmp(header, "$PostFormat", 11) || 
+            !strncmp(header, "$View", 5)) {
+      status = PView::readPOS(name);
+    }
+#endif
+    else {
+      status = m->readGEO(name);
+    }
+  }
+
+  SetBoundingBox();
+
+  CTX.geom.draw = 1;
+  CTX.mesh.changed = ENT_ALL;
+
+#if defined(HAVE_FLTK) && !defined(HAVE_NO_POST)
+  if(!CTX.batch && numViewsBefore != (int)PView::list.size())
+    WID->update_views();
+#endif
+
+  Msg::StatusBar(2, true, "Read '%s'", name);
+  return status;
+}
+
+void OpenProject(const char *name)
+{
+  if(CTX.threads_lock) {
+    Msg::Info("I'm busy! Ask me that later...");
+    return;
+  }
+  CTX.threads_lock = 1;
+
+  // FIXME: this will change once we clarify Open/Merge/Clear
+#if !defined(HAVE_NO_POST)
+  for(int i = PView::list.size() - 1; i >= 0; i--)
+    if(PView::list[i]->getData()->hasModel(GModel::current()))
+      delete PView::list[i];
+#endif
+  GModel::current()->destroy();
+  GModel::current()->getGEOInternals()->destroy();
+
+  // temporary hack until we fill the current GModel on the fly during
+  // parsing
+  ResetTemporaryBoundingBox();
+
+  SetProjectName(name);
+  MergeFile(name);
+
+  CTX.threads_lock = 0;
+
+#if defined(HAVE_FLTK)
+  if(!CTX.batch){
+    WID->reset_visibility();
+    WID->update_views();
+  }
+  ZeroHighlight();
+#endif
+}
+
+void OpenProjectMacFinder(const char *filename)
+{
+  static int first = 1;
+  if(first || CTX.batch){
+    // just copy the filename: it will be opened when the GUI is ready
+    // in main()
+    strncpy(CTX.filename, filename, 255);
+    first = 0;
+  }
+  else{
+    OpenProject(filename);
+#if defined(HAVE_FLTK)
+    Draw();
+#endif
+  }
+}

Common/OpenFile.h

+#ifndef _OPENFILE_H_
+#define _OPENFILE_H_
+
+// Copyright (C) 1997-2008 C. Geuzaine, J.-F. Remacle
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA.
+// 
+// Please report all bugs and problems to <gmsh@geuz.org>.
+
+int ParseFile(const char *filename, int close, int warn_if_missing=0);
+void ParseString(const char *str);
+void OpenProject(const char *filename);
+void OpenProjectMacFinder(const char *filename);
+int MergeFile(const char *filename, int warn_if_missing=0);
+void SetBoundingBox(double xmin, double xmax,
+                    double ymin, double ymax, 
+                    double zmin, double zmax);
+void SetBoundingBox();
+void AddToTemporaryBoundingBox(double x, double y, double z);
+
+#endif