コード例 #1
0
ファイル: graph-opengl.c プロジェクト: Solertis/duc
duc_graph *duc_graph_new_opengl(duc *duc, double font_scale)
{
	duc_graph *g = duc_graph_new(duc);
	g->backend = &duc_graph_backend_opengl;

	struct opengl_backend_data *bd;
	bd = duc_malloc(sizeof *bd);
	g->backend_data = bd;
	
	bd->sp = shaders();
	bd->loc_pos     = glGetAttribLocation(bd->sp, "pos_in");
	bd->loc_texture = glGetAttribLocation(bd->sp, "tex_in");
	bd->loc_color   = glGetAttribLocation(bd->sp, "color_in");
	bd->loc_sampler = glGetUniformLocation(bd->sp, "Texture");
	bd->loc_matrix  = glGetUniformLocation(bd->sp, "matrix");
	bd->font_scale  = font_scale / STB_SOMEFONT_LINE_SPACING;

	unsigned char fontpixels[STB_SOMEFONT_BITMAP_HEIGHT][STB_SOMEFONT_BITMAP_WIDTH];
	STB_SOMEFONT_CREATE(bd->fontdata, fontpixels, STB_SOMEFONT_BITMAP_HEIGHT);

	glGenTextures(1, &bd->font_texid);
	glBindTexture(GL_TEXTURE_2D, bd->font_texid);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, STB_SOMEFONT_BITMAP_WIDTH, STB_SOMEFONT_BITMAP_HEIGHT, 0, GL_ALPHA, GL_UNSIGNED_BYTE, fontpixels );
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glGenerateMipmap(GL_TEXTURE_2D);

	return g;
}
コード例 #2
0
ファイル: ducrc.c プロジェクト: Solertis/duc
struct ducrc *ducrc_new(const char *section)
{
	struct ducrc *ducrc;

	ducrc = duc_malloc(sizeof *ducrc);
	ducrc->noptions = 0;
	ducrc->section = duc_strdup(section);

	return ducrc;
}
コード例 #3
0
ファイル: dir.c プロジェクト: MSU-RCG/duc
struct duc_dir *duc_dir_new(struct duc *duc, dev_t dev, ino_t ino)
{
	struct duc_dir *dir = duc_malloc(sizeof(struct duc_dir));
	memset(dir, 0, sizeof *dir);

	dir->duc = duc;
	dir->dev = dev;
	dir->ino = ino;
	dir->path = NULL;
	dir->ent_cur = 0;
	dir->ent_count = 0;
	dir->size_apparent = 0;
	dir->size_actual = 0;
	dir->ent_pool = 32768;
	dir->ent_list = duc_malloc(dir->ent_pool);
	dir->size_type = -1;

	return dir;
}
コード例 #4
0
ファイル: graph-cairo.c プロジェクト: NethServer/duc
duc_graph *duc_graph_new_cairo(duc *duc, cairo_t *cr)
{
	duc_graph *g = duc_graph_new(duc);
	g->backend = &duc_graph_backend_cairo;

	struct cairo_backend_data *bd;
	bd = duc_malloc(sizeof *bd);
	g->backend_data = bd;

	bd->cr = cr;

	return g;
}
コード例 #5
0
ファイル: db-kyoto.c プロジェクト: Solertis/duc
struct db *db_open(const char *path_db, int flags, duc_errno *e)
{
	struct db *db;
	int compress = 0;

	uint32_t mode = KCOREADER;
	if(flags & DUC_OPEN_RW) mode |= KCOWRITER | KCOCREATE;
	if(flags & DUC_OPEN_COMPRESS) compress = 1;

	db = duc_malloc(sizeof *db);

	db->kdb = kcdbnew();

	db->kdb = kcdbnew();
	if(!db->kdb) {
		*e = DUC_E_DB_BACKEND;
		goto err1;
	}

	char fname[DUC_PATH_MAX];
	snprintf(fname, sizeof(fname), "%s.kct#opts=c", path_db);

	int r = kcdbopen(db->kdb, fname, mode);
	if(r == 0) {
		perror(kcecodename(kcdbecode(db->kdb)));
		*e = tcdb_to_errno(db->kdb);
		goto err2;
	}

	size_t vall;
	char *version = db_get(db, "duc_db_version", 14, &vall);
	if(version) {
		if(strcmp(version, DUC_DB_VERSION) != 0) {
			*e = DUC_E_DB_VERSION_MISMATCH;
			goto err3;
		}
		free(version);
	} else {
		db_put(db, "duc_db_version", 14, DUC_DB_VERSION, strlen(DUC_DB_VERSION));
	}

	return db;

err3:
	kcdbclose(db->kdb);
err2:
	kcdbdel(db->kdb);
err1:
	free(db);
	return NULL;
}
コード例 #6
0
ファイル: graph-cairo.c プロジェクト: NethServer/duc
duc_graph *duc_graph_new_cairo_file(duc *duc, duc_graph_file_format fmt, FILE *fout)
{
	duc_graph *g = duc_graph_new(duc);
	g->backend = &duc_graph_backend_file;

	struct cairo_backend_data *bd;
	bd = duc_malloc(sizeof *bd);
	g->backend_data = bd;
	
	bd->fmt = fmt;
	bd->fout = fout;

	return g;
}
コード例 #7
0
ファイル: graph-html.c プロジェクト: NethServer/duc
duc_graph *duc_graph_new_html(duc *duc, FILE *fout, int write_body)
{
	duc_graph *g = duc_graph_new(duc);
	g->backend = &duc_graph_backend_html;

	struct html_backend_data *bd;
	bd = duc_malloc(sizeof *bd);
	g->backend_data = bd;

	bd->fout = fout;
	bd->write_body = write_body;

	return g;
}
コード例 #8
0
ファイル: dir.c プロジェクト: NethServer/duc
struct duc_dir *duc_dir_new(struct duc *duc, const struct duc_devino *devino)
{
	size_t vall;
	char key[32];
	size_t keyl = snprintf(key, sizeof(key), "%jx/%jx", (uintmax_t)devino->dev, (uintmax_t)devino->ino);
	char *val = db_get(duc->db, key, keyl, &vall);
	if(val == NULL) {
		duc->err = DUC_E_PATH_NOT_FOUND;
		return NULL;
	}

	struct duc_dir *dir = duc_malloc0(sizeof(struct duc_dir));

	dir->duc = duc;
	dir->devino.dev = devino->dev;
	dir->devino.ino = devino->ino;
	dir->path = NULL;
	dir->ent_pool = 32768;
	dir->ent_list = duc_malloc(dir->ent_pool);
	dir->size_type = -1;

	struct buffer *b = buffer_new(val, vall);

	/* Read dir header */

	buffer_get_dir(b, &dir->devino_parent, &dir->mtime);

	/* Read all dirents */

	while(b->ptr < b->len) {

		if((dir->ent_count+1) * sizeof(struct duc_dirent) > dir->ent_pool) {
			dir->ent_pool *= 2;
			dir->ent_list = duc_realloc(dir->ent_list, dir->ent_pool);
		}

		struct duc_dirent *ent = &dir->ent_list[dir->ent_count];
		buffer_get_dirent(b, ent);

		duc_size_accum(&dir->size, &ent->size);
		dir->ent_count ++;
	}

	buffer_free(b);

	return dir;
}
コード例 #9
0
ファイル: stripdir.c プロジェクト: MSU-RCG/duc
char *stripdir(const char *dir)
{
	const char * in;
	char * out;
	char * last;
	int ldots;

	int maxlen = PATH_MAX;
	char *buf = duc_malloc(maxlen);
	in   = dir;
	out  = buf;
	last = buf + maxlen;
	ldots = 0;
	*out  = 0;


	if (*in != '/') {
		if (getcwd(buf, maxlen - 2) ) {
			out = buf + strlen(buf) - 1;
			if (*out != '/') *(++out) = '/';
			out++;
		}
		else {
			free(buf);
			return NULL;
		}
	}

	while (out < last) {
		*out = *in;

		if (*in == '/')
		{
			while (*(++in) == '/') ;
			in--;
		}

		if (*in == '/' || !*in)
		{
			if (ldots == 1 || ldots == 2) {
				while (ldots > 0 && --out > buf)
				{
					if (*out == '/')
						ldots--;
				}
				*(out+1) = 0;
			}
			ldots = 0;

		} else if (*in == '.' && ldots > -1) {
			ldots++;
		} else {
			ldots = -1;
		}

		out++;

		if (!*in)
			break;

		in++;
	}

	if (*in) {
		errno = ENOMEM;
		free(buf);
		return NULL;
	}

	while (--out != buf && (*out == '/' || !*out)) *out=0;
	return buf;
}