static void
write_nodes(FILE *fp, const NSegment *tree)
{
if (tree == NULL) return;
write_node(fp, tree);
write_nodes(fp, tree->left);
write_nodes(fp, tree->right);
}
/*==========================================
* write_nodes -- Write NODEs to GEDCOM file
*========================================*/
void
write_nodes (INT levl, /* level */
FILE *fp, /* file */
XLAT ttm, /* char map */
NODE node, /* root */
BOOLEAN indent, /* indent? */
BOOLEAN kids, /* output kids? */
BOOLEAN sibs) /* output sibs? */
{
if (!node) return;
write_node(levl, fp, ttm, node, indent);
if (kids)
write_nodes(levl+1, fp, ttm, nchild(node), indent, TRUE, TRUE);
if (sibs)
write_nodes(levl, fp, ttm, nsibling(node), indent, kids, TRUE);
}
int depcache_save(const char *filename, struct GRAPH *graph)
{
struct WRITEINFO info;
info.index = 0;
info.graph = graph;
info.fp = io_open_write(filename);
if(!io_valid(info.fp))
return -1;
cache_setup_header("DEP");
if(write_header(&info) || write_nodes(&info))
{
/* error occured, trunc the cache file so we don't leave a corrupted file */
printf("%s: warning: error saving cache file '%s', truncating it\n", session.name, filename);
io_close(info.fp);
io_close(io_open_write(filename));
return -1;
}
/* close up and return */
io_close(info.fp);
return 0;
}
void write_nodes(FILE *o, Lib3dsFile *f, Lib3dsNode *first_node) {
Lib3dsNode *p;
for (p = first_node; p; p = p->next) {
if (p->type == LIB3DS_NODE_MESH_INSTANCE) {
write_mesh(o, f, (Lib3dsMeshInstanceNode*)p);
write_nodes(o, f, p->childs);
}
}
}
ErrorCode WriteVtk::write_file(const char *file_name,
const bool overwrite,
const FileOptions& opts,
const EntityHandle *output_list,
const int num_sets,
const std::vector<std::string>& /* qa_list */,
const Tag* tag_list,
int num_tags,
int /* export_dimension */)
{
ErrorCode rval;
// Get precision for node coordinates
int precision;
if (MB_SUCCESS != opts.get_int_option("PRECISION", precision))
precision = DEFAULT_PRECISION;
if (MB_SUCCESS == opts.get_null_option("STRICT"))
mStrict = true;
else if (MB_SUCCESS == opts.get_null_option("RELAXED"))
mStrict = false;
else
mStrict = DEFAULT_STRICT;
// Get entities to write
Range nodes, elems;
rval = gather_mesh(output_list, num_sets, nodes, elems);
if (MB_SUCCESS != rval)
return rval;
// Honor overwrite flag
if (!overwrite) {
rval = writeTool->check_doesnt_exist(file_name);
if (MB_SUCCESS != rval)
return rval;
}
// Create file
std::ofstream file(file_name);
if (!file) {
MB_SET_ERR(MB_FILE_WRITE_ERROR, "Could not open file: " << file_name);
}
file.precision(precision);
// Write file
if ((rval = write_header(file )) != MB_SUCCESS ||
(rval = write_nodes( file, nodes )) != MB_SUCCESS ||
(rval = write_elems( file, nodes, elems)) != MB_SUCCESS ||
(rval = write_tags ( file, true, nodes, tag_list, num_tags)) != MB_SUCCESS ||
(rval = write_tags ( file, false, elems, tag_list, num_tags)) != MB_SUCCESS) {
file.close();
remove(file_name);
return rval;
}
return MB_SUCCESS;
}
static void write_graph(Agraph_t * g, GVJ_t * job, int top, state_t* sp)
{
Agnode_t* np;
Agedge_t* ep;
int ncnt = 0;
int ecnt = 0;
int sgcnt = 0;
int has_subgs;
Dt_t* map;
if (top) {
map = dtopen (&intDisc, Dtoset);
aginit(g, AGNODE, ID, sizeof(gvid_t), FALSE);
aginit(g, AGEDGE, ID, sizeof(gvid_t), FALSE);
aginit(g, AGRAPH, ID, -((int)sizeof(gvid_t)), FALSE);
sgcnt = label_subgs(g, sgcnt, map);
for (np = agfstnode(g); np; np = agnxtnode(g,np)) {
if (IS_CLUSTER(np)) {
ND_gid(np) = lookup(map, agnameof(np));
}
else {
ND_gid(np) = sgcnt + ncnt++;
}
for (ep = agfstout(g, np); ep; ep = agnxtout(g,ep)) {
ED_gid(ep) = ecnt++;
}
}
dtclose(map);
}
indent(job, sp->Level++);
gvputs(job, "{\n");
write_hdr(g, job, top, sp);
write_attrs((Agobj_t*)g, job, sp);
if (top) {
gvputs(job, ",\n");
indent(job, sp->Level);
gvprintf(job, "\"_subgraph_cnt\": %d", sgcnt);
} else {
gvputs(job, ",\n");
indent(job, sp->Level);
gvprintf(job, "\"_gvid\": %d", GD_gid(g));
}
has_subgs = write_subgs(g, job, top, sp);
write_nodes (g, job, top, has_subgs, sp);
write_edges (g, job, top, sp);
gvputs(job, "\n");
sp->Level--;
indent(job, sp->Level);
if (top)
gvputs(job, "}\n");
else
gvputs(job, "}");
}
/*========================================================
* write_node_to_editfile - write all parts of gedcom node
* to a file for editing
*======================================================*/
void
write_node_to_editfile (NODE node)
{
FILE *fp;
XLAT ttmo = transl_get_predefined_xlat(MINED);
ASSERT(fp = fopen(editfile, LLWRITETEXT));
prefix_file_for_edit(fp);
write_nodes(0, fp, ttmo, node, TRUE, TRUE, TRUE);
fclose(fp);
}
/*============================================
* node_to_file -- Convert tree to GEDCOM file
*==========================================*/
BOOLEAN
node_to_file (INT levl, /* top level */
NODE node, /* root node */
STRING fname, /* file */
BOOLEAN indent, /* indent? */
TRANTABLE tt) /* char map */
{
FILE *fp;
if (!(fp = fopen(fname, LLWRITETEXT))) {
llwprintf("Could not open file: `%s'\n", fname);
return FALSE;
}
write_nodes(levl, fp, tt, node, indent, TRUE, TRUE);
fclose(fp);
return TRUE;
}
/*=================================================================
* advanced_person_edit --
*===============================================================*/
void
advanced_person_edit (NODE root0)
{
FILE *fp;
NODE expd;
#ifdef DEBUG
llwprintf("advanced_person_edit: %s %s %s\n", nxref(root0),
ntag(root0),nval(root0));
#endif
expd = expand_tree(root0);
ASSERT(fp = fopen(editfile, LLWRITETEXT));
write_nodes(0, fp, NULL, expd, TRUE, TRUE, TRUE);
fclose(fp);
do_edit();
}
int main(int argc, char **argv) {
Lib3dsFile *f;
parse_args(argc, argv);
f = lib3ds_file_open(input);
if (!f) {
fprintf(stderr, "***ERROR***\nLoading file failed: %s\n", input);
exit(1);
}
if (mtl_file) {
FILE *mtl = fopen(mtl_file, "wt");
if (!mtl) {
fprintf(stderr, "***ERROR***\nCreating output file failed: %s\n", mtl_file);
exit(1);
}
write_mtl(mtl, f);
fclose(mtl);
}
{
FILE *obj = fopen(obj_file, "wt");
if (!obj) {
fprintf(stderr, "***ERROR***\nCreating output file failed: %s\n", obj_file);
exit(1);
}
if (!f->nodes)
lib3ds_file_create_nodes_for_meshes(f);
lib3ds_file_eval(f, 0);
fprintf(obj, "# Wavefront OBJ file\n");
fprintf(obj, "# Converted by 3ds2obj\n");
fprintf(obj, "# http://www.lib3ds.org\n\n");
if (mtl_file) {
fprintf(obj, "mtllib %s\n", mtl_file);
}
write_nodes(obj, f, f->nodes);
fclose(obj);
}
lib3ds_file_free(f);
return 0;
}
/*=====================================
* write_indi_to_file - write node tree into GEDCOM
* (no user interaction)
*===================================*/
void
write_indi_to_file (NODE indi, CNSTRING file)
{
FILE *fp;
XLAT ttmo = transl_get_predefined_xlat(MINED);
NODE name, refn, sex, body, famc, fams;
ASSERT(fp = fopen(file, LLWRITETEXT));
prefix_file(fp, ttmo);
split_indi_old(indi, &name, &refn, &sex, &body, &famc, &fams);
write_nodes(0, fp, ttmo, indi, TRUE, TRUE, TRUE);
write_nodes(1, fp, ttmo, name, TRUE, TRUE, TRUE);
write_nodes(1, fp, ttmo, refn, TRUE, TRUE, TRUE);
write_nodes(1, fp, ttmo, sex, TRUE, TRUE, TRUE);
write_nodes(1, fp, ttmo, body , TRUE, TRUE, TRUE);
write_nodes(1, fp, ttmo, famc, TRUE, TRUE, TRUE);
write_nodes(1, fp, ttmo, fams, TRUE, TRUE, TRUE);
fclose(fp);
join_indi(indi, name, refn, sex, body, famc, fams);
}
void
write_dot(const NSegment *node, const NSegment *subtree,
const NSegment *inserted, const char *name)
{
assert(node != NULL);
assert(name != NULL);
subtree_root = subtree; // globalise
inserted_node = inserted; // globalise
char file[strlen(name) + 10];
sprintf(file, "%s.dot", name); // construct file name
FILE *fp = fopen(file, "w");
assert(fp);
fprintf(fp, "digraph \"%s\" {\n", name);
fprintf(fp, "\n/* Nodes */\n\n");
write_nodes(fp, node);
fprintf(fp, "\n/* Edges */\n\n");
write_edges(fp, node);
fprintf(fp, "}\n");
fclose(fp);
}
/*=====================================
* write_fam_to_file -- write node tree into GEDCOM
* (no user interaction)
*===================================*/
static void
write_fam_to_file (NODE fam, CNSTRING file)
{
FILE *fp;
XLAT ttmo = transl_get_predefined_xlat(MINED);
NODE refn, husb, wife, chil, body;
ASSERT(fp = fopen(file, LLWRITETEXT));
prefix_file(fp, ttmo);
split_fam(fam, &refn, &husb, &wife, &chil, &body);
write_nodes(0, fp, ttmo, fam, TRUE, TRUE, TRUE);
write_nodes(1, fp, ttmo, refn, TRUE, TRUE, TRUE);
write_nodes(1, fp, ttmo, husb, TRUE, TRUE, TRUE);
write_nodes(1, fp, ttmo, wife, TRUE, TRUE, TRUE);
write_nodes(1, fp, ttmo, body, TRUE, TRUE, TRUE);
write_nodes(1, fp, ttmo, chil, TRUE, TRUE, TRUE);
join_fam(fam, refn, husb, wife, chil, body);
fclose(fp);
}
ErrorCode WriteTemplate::write_file(const char *file_name,
const bool /* overwrite (commented out to remove warning) */,
const FileOptions& /*opts*/,
const EntityHandle *ent_handles,
const int num_sets,
const std::vector<std::string>&,
const Tag* ,
int ,
int )
{
assert(0 != mMaterialSetTag &&
0 != mNeumannSetTag &&
0 != mDirichletSetTag);
// check the file name
if (NULL == strstr(file_name, ".template"))
return MB_FAILURE;
std::vector<EntityHandle> matsets, dirsets, neusets, entities;
fileName = file_name;
// separate into material sets, dirichlet sets, neumann sets
if (num_sets == 0) {
// default to all defined sets
Range this_range;
mbImpl->get_entities_by_type_and_tag(0, MBENTITYSET, &mMaterialSetTag, NULL, 1, this_range);
std::copy(this_range.begin(), this_range.end(), std::back_inserter(matsets));
this_range.clear();
mbImpl->get_entities_by_type_and_tag(0, MBENTITYSET, &mDirichletSetTag, NULL, 1, this_range);
std::copy(this_range.begin(), this_range.end(), std::back_inserter(dirsets));
this_range.clear();
mbImpl->get_entities_by_type_and_tag(0, MBENTITYSET, &mNeumannSetTag, NULL, 1, this_range);
std::copy(this_range.begin(), this_range.end(), std::back_inserter(neusets));
}
else {
int dummy;
for (const EntityHandle *iter = ent_handles; iter < ent_handles+num_sets; iter++)
{
if (MB_SUCCESS == mbImpl->tag_get_data(mMaterialSetTag, &(*iter), 1, &dummy))
matsets.push_back(*iter);
else if (MB_SUCCESS == mbImpl->tag_get_data(mDirichletSetTag, &(*iter), 1, &dummy))
dirsets.push_back(*iter);
else if (MB_SUCCESS == mbImpl->tag_get_data(mNeumannSetTag, &(*iter), 1, &dummy))
neusets.push_back(*iter);
}
}
// if there is nothing to write just return.
if (matsets.empty() && dirsets.empty() && neusets.empty())
return MB_FILE_WRITE_ERROR;
std::vector<WriteTemplate::MaterialSetData> matset_info;
std::vector<WriteTemplate::DirichletSetData> dirset_info;
std::vector<WriteTemplate::NeumannSetData> neuset_info;
MeshInfo mesh_info;
matset_info.clear();
if(gather_mesh_information(mesh_info, matset_info, neuset_info, dirset_info,
matsets, neusets, dirsets) != MB_SUCCESS)
{
reset_matset(matset_info);
return MB_FAILURE;
}
// try to open the file after gather mesh info succeeds
if (/* test for file open failure */ false) {
reset_matset(matset_info);
return MB_FAILURE;
}
if( initialize_file(mesh_info) != MB_SUCCESS)
{
reset_matset(matset_info);
return MB_FAILURE;
}
if( write_nodes(mesh_info.num_nodes, mesh_info.nodes, mesh_info.num_dim) != MB_SUCCESS )
{
reset_matset(matset_info);
return MB_FAILURE;
}
if( write_matsets(mesh_info, matset_info, neuset_info) )
{
reset_matset(matset_info);
return MB_FAILURE;
}
return MB_SUCCESS;
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
int i; /* Looping var */
char path[1024], /* Path to documentation */
line[1024]; /* Line from file */
help_index_t *hi; /* Help index */
cups_file_t *tokens, /* Tokens.xml file */
*fp; /* Current file */
if (argc < 4)
{
puts("Usage: makedocset directory revision *.tokens");
return (1);
}
/*
* Index the help documents...
*/
snprintf(path, sizeof(path), "%s/Contents/Resources/Documentation", argv[1]);
if ((hi = helpLoadIndex(NULL, path)) == NULL)
{
fputs("makedocset: Unable to index help files!\n", stderr);
return (1);
}
snprintf(path, sizeof(path), "%s/Contents/Resources/Documentation/index.html",
argv[1]);
write_index(path, hi);
snprintf(path, sizeof(path), "%s/Contents/Resources/Nodes.xml", argv[1]);
write_nodes(path, hi);
/*
* Write the Info.plist file...
*/
snprintf(path, sizeof(path), "%s/Contents/Info.plist", argv[1]);
write_info(path, argv[2]);
/*
* Merge the Tokens.xml files...
*/
snprintf(path, sizeof(path), "%s/Contents/Resources/Tokens.xml", argv[1]);
if ((tokens = cupsFileOpen(path, "w")) == NULL)
{
fprintf(stderr, "makedocset: Unable to create \"%s\": %s\n", path,
strerror(errno));
return (1);
}
cupsFilePuts(tokens, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
cupsFilePuts(tokens, "<Tokens version=\"1.0\">\n");
for (i = 3; i < argc; i ++)
{
if ((fp = cupsFileOpen(argv[i], "r")) == NULL)
{
fprintf(stderr, "makedocset: Unable to open \"%s\": %s\n", argv[i],
strerror(errno));
return (1);
}
if (!cupsFileGets(fp, line, sizeof(line)) || strncmp(line, "<?xml ", 6) ||
!cupsFileGets(fp, line, sizeof(line)) || strncmp(line, "<Tokens ", 8))
{
fprintf(stderr, "makedocset: Bad Tokens.xml file \"%s\"!\n", argv[i]);
return (1);
}
while (cupsFileGets(fp, line, sizeof(line)))
{
if (strcmp(line, "</Tokens>"))
cupsFilePrintf(tokens, "%s\n", line);
}
cupsFileClose(fp);
}
cupsFilePuts(tokens, "</Tokens>\n");
cupsFileClose(tokens);
/*
* Return with no errors...
*/
return (0);
}