void RenderSystem::v_Init()
{
init_device();
init_camera();
init_object();
}
void D3D11Render::v_init()
{
init_device();
init_camera();
init_object();
sound.Init();
}
int ustctl_create_event(int sock, struct lttng_ust_event *ev,
struct lttng_ust_object_data *channel_data,
struct lttng_ust_object_data **_event_data)
{
struct ustcomm_ust_msg lum;
struct ustcomm_ust_reply lur;
struct lttng_ust_object_data *event_data;
int ret;
if (!channel_data || !_event_data)
return -EINVAL;
event_data = malloc(sizeof(*event_data));
if (!event_data)
return -ENOMEM;
init_object(event_data);
memset(&lum, 0, sizeof(lum));
lum.handle = channel_data->handle;
lum.cmd = LTTNG_UST_EVENT;
strncpy(lum.u.event.name, ev->name,
LTTNG_UST_SYM_NAME_LEN);
lum.u.event.instrumentation = ev->instrumentation;
lum.u.event.loglevel_type = ev->loglevel_type;
lum.u.event.loglevel = ev->loglevel;
ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret) {
free(event_data);
return ret;
}
event_data->handle = lur.ret_val;
DBG("received event handle %u", event_data->handle);
*_event_data = event_data;
return 0;
}
int ustctl_add_context(int sock, struct lttng_ust_context *ctx,
struct lttng_ust_object_data *obj_data,
struct lttng_ust_object_data **_context_data)
{
struct ustcomm_ust_msg lum;
struct ustcomm_ust_reply lur;
struct lttng_ust_object_data *context_data;
int ret;
if (!obj_data || !_context_data)
return -EINVAL;
context_data = malloc(sizeof(*context_data));
if (!context_data)
return -ENOMEM;
init_object(context_data);
memset(&lum, 0, sizeof(lum));
lum.handle = obj_data->handle;
lum.cmd = LTTNG_UST_CONTEXT;
lum.u.context.ctx = ctx->ctx;
ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret) {
free(context_data);
return ret;
}
context_data->handle = lur.ret_val;
DBG("received context handle %u", context_data->handle);
*_context_data = context_data;
return ret;
}
static noinline int alloc_debug_processing(struct kmem_cache *s, struct page *page,
void *object, unsigned long addr)
{
if (!check_slab(s, page))
goto bad;
if (!check_valid_pointer(s, page, object)) {
object_err(s, page, object, "Freelist Pointer check fails");
goto bad;
}
if (!check_object(s, page, object, SLUB_RED_INACTIVE))
goto bad;
/* Success perform special debug activities for allocs */
if (s->flags & SLAB_STORE_USER)
set_track(s, object, TRACK_ALLOC, addr);
trace(s, page, object, 1);
init_object(s, object, SLUB_RED_ACTIVE);
return 1;
bad:
if (PageSlab(page)) {
/*
* If this is a slab page then lets do the best we can
* to avoid issues in the future. Marking all objects
* as used avoids touching the remaining objects.
*/
slab_fix(s, "Marking all objects used");
page->inuse = page->objects;
page->freelist = NULL;
}
return 0;
}
static Variant HHVM_FUNCTION(mysql_fetch_object,
const Variant& var_result,
const String& class_name /* = "stdClass" */,
const Variant& params /* = null */) {
Resource result = var_result.isResource() ? var_result.toResource()
: null_resource;
Variant properties = php_mysql_fetch_hash(result, PHP_MYSQL_ASSOC);
if (!same(properties, false)) {
Object obj;
const auto paramsArray = params.isArray()
? params.asCArrRef()
: Array();
// We need to create an object without initialization (constructor call),
// and set the fetched fields as dynamic properties on the object prior
// calling the constructor.
obj = create_object_only(class_name);
// Set the fields.
obj->o_setArray(properties.toArray());
// And finally initialize the object by calling the constructor.
obj = init_object(class_name, paramsArray, obj.get());
return obj;
}
return false;
}
int main(int argc, char *argv[]) {
FILE *inf;
wave_object_t obj;
const size_t NUM_FRAMES = 360;
RtInt md = 4;
scene_info_t scene;
double rad = 20;
double t = 0.0;
double dt = 2.0*PI/(NUM_FRAMES-1);
size_t fnum;
if (argc <3) {
printf("No input and output file names given!\n");
return 1;
}
inf = fopen(argv[1], "rt");
if (inf == NULL) {
printf("Could not open \"%s\"\n", argv[1]);
return 1;
}
init_object(&obj);
read_object(inf, &obj);
printf("Object file has:\n %zu vertices\n %zu normals\n %zu texture coordinates\n %zu faces\n %d objects\n",
obj.num_verts, obj.num_norms, obj.num_texts, obj.num_faces, 1);
RiBegin(RI_NULL);
RiOption("trace", "maxdepth", &md, RI_NULL);
RiSides(2);
scene.cam.location[0] = rad;
scene.cam.location[1] = rad;
scene.cam.location[2] = rad;
scene.cam.look_at[0]= 0.0;
scene.cam.look_at[1]= 0.0;
scene.cam.look_at[2]= 0.0;
scene.cam.roll = 0.0;
scene.fprefix = argv[2];
for (fnum = 0; fnum < NUM_FRAMES; ++fnum) {
scene.cam.location[0] = rad * sin(t);
scene.cam.location[2] = rad * cos(t);
t += dt;
printf("Rendering frame %lu\n", fnum);
doFrame(fnum, &scene, &obj);
}
RiEnd();
free_object(&obj);
fclose(inf);
return 0;
}
void *vmmap(void *addr, unsigned long size, int protect, struct file *filp, off64_t offset, int *rc) {
int pages = PAGES(size);
unsigned long flags = pte_flags_from_protect(protect);
struct filemap *fm;
int i;
char *vaddr;
if (rc) *rc = 0;
if (size == 0 || flags == 0xFFFFFFFF) {
if (rc) *rc = -EINVAL;
return NULL;
}
addr = (void *) PAGEADDR(addr);
if (addr == NULL) {
addr = (void *) PTOB(rmap_alloc(vmap, pages));
if (addr == NULL) {
if (rc) *rc = -ENOMEM;
return NULL;
}
} else {
if (rmap_reserve(vmap, BTOP(addr), pages)) {
if (rc) *rc = -ENOMEM;
return NULL;
}
}
fm = (struct filemap *) kmalloc(sizeof(struct filemap));
if (!fm) {
rmap_free(vmap, BTOP(addr), pages);
if (rc) *rc = -ENOMEM;
return NULL;
}
init_object(&fm->object, OBJECT_FILEMAP);
fm->self = halloc(&fm->object);
fm->file = halloc(&filp->iob.object);
if (fm->self < 0 || fm->file < 0) {
if (rc) *rc = -ENFILE;
return NULL;
}
hprotect(fm->self);
hprotect(fm->file);
fm->offset = offset;
fm->pages = pages;
fm->object.signaled = 1;
fm->addr = addr;
fm->size = size;
fm->protect = flags | PT_FILE;
vaddr = (char *) addr;
flags = (flags & ~PT_USER) | PT_FILE;
for (i = 0; i < pages; i++) {
map_page(vaddr, fm->self, flags);
vaddr += PAGESIZE;
}
return addr;
}
/* Object debug checks for alloc/free paths */
static void setup_object_debug(struct kmem_cache *s, struct page *page,
void *object)
{
if (!(s->flags & (SLAB_STORE_USER|SLAB_RED_ZONE|__OBJECT_POISON)))
return;
init_object(s, object, SLUB_RED_INACTIVE);
init_tracking(s, object);
}
/*
* Return -ENOENT if no more stream is available for creation.
* Return 0 on success.
* Return negative error value on error.
*/
int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data,
struct lttng_ust_object_data **_stream_data)
{
struct ustcomm_ust_msg lum;
struct ustcomm_ust_reply lur;
struct lttng_ust_object_data *stream_data;
int ret, fd, err = 0;
if (!channel_data || !_stream_data)
return -EINVAL;
stream_data = malloc(sizeof(*stream_data));
if (!stream_data)
return -ENOMEM;
init_object(stream_data);
memset(&lum, 0, sizeof(lum));
lum.handle = channel_data->handle;
lum.cmd = LTTNG_UST_STREAM;
ret = ustcomm_send_app_cmd(sock, &lum, &lur);
if (ret) {
free(stream_data);
return ret;
}
if (lur.ret_code != USTCOMM_OK) {
free(stream_data);
return lur.ret_code;
}
stream_data->handle = lur.ret_val;
DBG("received stream handle %u", stream_data->handle);
stream_data->memory_map_size = lur.u.stream.memory_map_size;
/* get shm fd */
fd = ustcomm_recv_fd(sock);
if (fd < 0)
err = 1;
else
stream_data->shm_fd = fd;
/*
* We need to get the second FD even if the first fails, because
* libust expects us to read the two FDs.
*/
/* get wait fd */
fd = ustcomm_recv_fd(sock);
if (fd < 0)
err = 1;
else
stream_data->wait_fd = fd;
if (err)
goto error;
*_stream_data = stream_data;
return ret;
error:
(void) ustctl_release_object(sock, stream_data);
free(stream_data);
return -EINVAL;
}
struct refl_object *
__refl_object_begin_inline (struct refl_type *type, size_t size)
{
struct refl_object *result = __refl_malloc (sizeof (*result) + size);
if (result == NULL)
return NULL;
init_object (result, type, (unsigned char *)(result + 1));
return result;
}
struct refl_object *
__refl_object_begin (struct refl_type *type, void *data)
{
struct refl_object *result = __refl_malloc (sizeof (*result));
if (result == NULL)
return NULL;
init_object (result, type, data);
return result;
}
ATTR_COLD void netlist_core_device_t::init(netlist_base_t &anetlist, const pstring &name)
{
init_object(anetlist, name);
#if USE_PMFDELEGATES
void (netlist_core_device_t::* pFunc)() = &netlist_core_device_t::update;
static_update = reinterpret_cast<net_update_delegate>((this->*pFunc));
#endif
}
int
deluge_disseminate(char *file, unsigned version)
{
/* This implementation disseminates at most one object. */
if(next_object_id > 0 || init_object(¤t_object, file, version) < 0) {
return -1;
}
process_start(&deluge_process, (void *)file);
return 0;
}
//---------------------------------------------------------------------------//
void
Schema::set(const DataType &dtype)
{
reset();
if (dtype.id() == DataType::OBJECT_ID) {
init_object();
} else if (dtype.id() == DataType::LIST_ID) {
init_list();
}
m_dtype = dtype;
}
static void draw_object(int i, int j, int f, float a)
{
struct object *o = get_object(i);
struct object_mesh *m = NULL;
float alpha = get_entity_alpha(j) * a;
init_object(i);
glPushMatrix();
{
/* Apply the local coordinate system transformation. */
transform_entity(j);
/* Render this object. */
if (test_entity_aabb(j) >= 0)
{
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
glPushAttrib(GL_LIGHTING_BIT | GL_TEXTURE_BIT);
{
int k, n = vecnum(o->mv);
/* Bind a vertex buffer or array. */
if (GL_has_vertex_buffer_object)
{
glBindBufferARB(GL_ARRAY_BUFFER_ARB, o->buffer);
draw_vert(0);
}
else
draw_vert(vecget(o->vv, 0));
/* Draw each surface. */
for (k = 0; k < n; ++k)
{
m = (struct object_mesh *) vecget(o->mv, k);
if (vecnum(m->fv) > 0 || vecnum(m->ev) > 0)
draw_mesh(m, alpha);
}
}
glPopAttrib();
glPopClientAttrib();
}
/* Render all child entities in this coordinate system. */
draw_entity_tree(j, f, a * get_entity_alpha(j));
}
glPopMatrix();
}
static noinline int free_debug_processing(struct kmem_cache *s,
struct page *page, void *object, unsigned long addr)
{
unsigned long flags;
int rc = 0;
local_irq_save(flags);
slab_lock(page);
if (!check_slab(s, page))
goto fail;
if (!check_valid_pointer(s, page, object)) {
slab_err(s, page, "Invalid object pointer 0x%p", object);
goto fail;
}
if (on_freelist(s, page, object)) {
object_err(s, page, object, "Object already free");
goto fail;
}
if (!check_object(s, page, object, SLUB_RED_ACTIVE))
goto out;
if (unlikely(s != page->slab)) {
if (!PageSlab(page)) {
slab_err(s, page, "Attempt to free object(0x%p) "
"outside of slab", object);
} else if (!page->slab) {
printk(KERN_ERR
"SLUB <none>: no slab for object 0x%p.\n",
object);
dump_stack();
} else
object_err(s, page, object,
"page slab pointer corrupt.");
goto fail;
}
if (s->flags & SLAB_STORE_USER)
set_track(s, object, TRACK_FREE, addr);
trace(s, page, object, 0);
init_object(s, object, SLUB_RED_INACTIVE);
rc = 1;
out:
slab_unlock(page);
local_irq_restore(flags);
return rc;
fail:
slab_fix(s, "Object at 0x%p not freed", object);
goto out;
}
Block * make_block(float x, float y, float width, float height, int health) {
Block * block = (Block *)malloc(sizeof(Block));
init_object(block);
block->health = health;
set_object_position(block, x, y);
set_object_size(block, width, height);
set_object_image(block, resources.block_bmp[block->health - 1]);
return block;
}
void init_zero_from_lib(DomainDesc * domain, SharedLibDesc * zeroLib)
{
domain = domainZero;
portalInterface = findClassDescInSharedLib(zeroLib, "jx/zero/Portal");
init_bootfs_portal();
init_cas_portal();
init_clock_portal();
init_componentmanager_portal();
init_cpumanager_portal();
init_cpustate_portal();
init_credential_portal();
// init_debugchannel_portal();
// init_debugsupport_portal();
init_domain_portal();
init_domainmanager_portal();
init_irq_portal();
init_memory_portal();
init_memorymanager_portal();
init_mutex_portal();
init_naming_portal();
init_ports_portal();
init_vmclass_portal();
init_vmmethod_portal();
init_vmobject_portal();
#ifdef FRAMEBUFFER_EMULATION
init_fbemulation_portal();
#endif /* FRAMEBUFFER_EMULATION */
#ifdef DISK_EMULATION
init_disk_emulation_portal();
#endif /* DISK_EMULATION */
#ifdef NET_EMULATION
init_net_emulation_portal();
#endif /* NET_EMULATION */
#ifdef TIMER_EMULATION
init_timer_emulation_portal();
#endif /* TIMER_EMULATION */
/* now we can add a vtable to the DomainZero Domain object */
//domainDesc2Obj(domainZero)->vtable = (u32)domainClass->vtable;
/* add zero vtables */
addZeroVtables();
init_object();
}
Player * make_player(const char * name, float x, float y, float width, float height, SDL_Surface * image) {
Player * player = (Player *)malloc(sizeof(Player));
init_object(player);
player->name = (char *)malloc(strlen(name) + 1);
strcpy(player->name, name);
set_object_position(player, x, y);
set_object_size(player, width, height);
set_object_image(player, image);
return player;
}
ATTR_COLD void netlist_core_device_t::init(netlist_base_t &anetlist, const pstring &name)
{
set_logic_family(this->default_logic_family());
init_object(anetlist, name);
#if USE_PMFDELEGATES
void (netlist_core_device_t::* pFunc)() = &netlist_core_device_t::update;
#if NO_USE_PMFCONVERSION
static_update = pFunc;
#else
static_update = reinterpret_cast<net_update_delegate>((this->*pFunc));
#endif
#endif
}
void init(t_env *raytracer, const char *file)
{
int i;
i = -1;
while (++i < MAX)
raytracer->objects[i] = NULL;
init_object(raytracer, file);
raytracer->mlx_ptr = mlx_init();
raytracer->win_ptr = mlx_new_window(raytracer->mlx_ptr, WIDTH, HEIGHT, "RAYTRACER");
mlx_clear_window(raytracer->mlx_ptr, raytracer->win_ptr);
raytracer->screen = create_new_image(raytracer->mlx_ptr, WIDTH, HEIGHT);
mlx_key_hook(raytracer->win_ptr, key_hook, raytracer);
mlx_expose_hook(raytracer->win_ptr, expose_hook, raytracer);
}
void initDefault(void)
{
armData.x = 0.0;
armData.y = (LARGE_CUBE_SIZE /2 )-1;
armData.z = 0.0;
armData.visible = UNVISIBLE;
armData.inputDirection = INPUT_NO_DIRECTION;
armData.inputEnable = INPUT_ENABLE;
armData.inAnimation = IN_CONTROL;
armData.counter = 0;
init_light();
init_texture();
init_object();
}
ATTR_COLD void core_device_t::init(netlist_t &anetlist, const pstring &name)
{
if (logic_family() == nullptr)
set_logic_family(this->default_logic_family());
init_object(anetlist, name);
#if (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF)
void (core_device_t::* pFunc)() = &core_device_t::update;
m_static_update = pFunc;
#elif (NL_PMF_TYPE == NL_PMF_TYPE_GNUC_PMF_CONV)
void (core_device_t::* pFunc)() = &core_device_t::update;
m_static_update = reinterpret_cast<net_update_delegate>((this->*pFunc));
#elif (NL_PMF_TYPE == NL_PMF_TYPE_INTERNAL)
m_static_update = pmfp::get_mfp<net_update_delegate>(&core_device_t::update, this);
#endif
}
PUBLIC int main(int argc, char *argv[]) {
if (argc < 2) {
fprintf(stderr,
"Usage: move [-t] <dbfilename> [<move-source-code-file> ...]\n"
"\t-t\tInhibits loading threads which were active when the DB was saved\n");
exit(MOVE_EXIT_ERROR);
}
signal(SIGINT, siginthandler); /* %%% This can be made to emergency-flush
the database to disk, later on %%% */
write_pid();
init_gc();
init_object();
init_prim();
init_vm_global();
init_thread();
checkpoint_filename = "move.checkpoint";
install_primitives();
{
int load_threads = 1;
if (!strcmp(argv[1], "-t")) {
load_threads = 0;
argv++;
argc--;
}
import_db(argv[1], load_threads);
}
bind_primitives_to_symbols();
import_cmdline_files(argc - 2, argv + 2);
run_main_loop();
done_gc();
return MOVE_EXIT_OK;
}
void initialize_KIM()
{
int i;
printf("\nInitializing KIM ... started\n");
/* create KIM objects and do the necessary initialization */
init_object();
/* create free parameter data sturct and nest optimizable parameters */
init_optimizable_param();
for (i = 0; i <g_config.nconf; i++) {
/* Publish cutoff (only needs to be published once, so here) */
publish_cutoff(g_kim.pkimObj[i], g_config.rcutmax);
}
printf("Initializing KIM ... done\n");
}
//---------------------------------------------------------------------------//
Schema &
Schema::fetch(const std::string &path)
{
// fetch w/ path forces OBJECT_ID
init_object();
std::string p_curr;
std::string p_next;
utils::split_path(path,p_curr,p_next);
// handle parent
// check for parent
if(p_curr == "..")
{
if(m_parent != NULL) // TODO: check for error (no parent)
return m_parent->fetch(p_next);
}
if (!has_path(p_curr))
{
Schema* my_schema = new Schema();
my_schema->m_parent = this;
children().push_back(my_schema);
object_map()[p_curr] = children().size() - 1;
object_order().push_back(p_curr);
}
index_t idx = child_index(p_curr);
if(p_next.empty())
{
return *children()[idx];
}
else
{
return children()[idx]->fetch(p_next);
}
}
//---------------------------------------------------------------------------//
void
Schema::set(const Schema &schema)
{
bool init_children = false;
index_t dt_id = schema.m_dtype.id();
if (dt_id == DataType::OBJECT_ID)
{
init_object();
init_children = true;
object_map() = schema.object_map();
object_order() = schema.object_order();
}
else if (dt_id == DataType::LIST_ID)
{
init_list();
init_children = true;
}
else
{
m_dtype = schema.m_dtype;
}
if (init_children)
{
std::vector<Schema*> &my_children = children();
const std::vector<Schema*> &their_children = schema.children();
for (index_t i = 0; i < (index_t)their_children.size(); i++)
{
Schema *child_schema = new Schema(*their_children[i]);
child_schema->m_parent = this;
my_children.push_back(child_schema);
}
}
}
/*
* Display a dialog box for entering a date
*/
int
dialog_calendar(const char *title,
const char *subtitle,
int height,
int width,
int day,
int month,
int year)
{
/* *INDENT-OFF* */
static DLG_KEYS_BINDING binding[] = {
HELPKEY_BINDINGS,
ENTERKEY_BINDINGS,
DLG_KEYS_DATA( DLGK_ENTER, ' ' ),
DLG_KEYS_DATA( DLGK_FIELD_NEXT, TAB ),
DLG_KEYS_DATA( DLGK_FIELD_PREV, KEY_BTAB ),
DLG_KEYS_DATA( DLGK_GRID_DOWN, 'j' ),
DLG_KEYS_DATA( DLGK_GRID_DOWN, DLGK_MOUSE(KEY_NPAGE) ),
DLG_KEYS_DATA( DLGK_GRID_DOWN, KEY_DOWN ),
DLG_KEYS_DATA( DLGK_GRID_DOWN, KEY_NPAGE ),
DLG_KEYS_DATA( DLGK_GRID_LEFT, '-' ),
DLG_KEYS_DATA( DLGK_GRID_LEFT, 'h' ),
DLG_KEYS_DATA( DLGK_GRID_LEFT, CHR_BACKSPACE ),
DLG_KEYS_DATA( DLGK_GRID_LEFT, CHR_PREVIOUS ),
DLG_KEYS_DATA( DLGK_GRID_LEFT, KEY_LEFT ),
DLG_KEYS_DATA( DLGK_GRID_RIGHT, '+' ),
DLG_KEYS_DATA( DLGK_GRID_RIGHT, 'l' ),
DLG_KEYS_DATA( DLGK_GRID_RIGHT, CHR_NEXT ),
DLG_KEYS_DATA( DLGK_GRID_RIGHT, KEY_NEXT ),
DLG_KEYS_DATA( DLGK_GRID_RIGHT, KEY_RIGHT ),
DLG_KEYS_DATA( DLGK_GRID_UP, 'k' ),
DLG_KEYS_DATA( DLGK_GRID_UP, KEY_PPAGE ),
DLG_KEYS_DATA( DLGK_GRID_UP, KEY_PREVIOUS ),
DLG_KEYS_DATA( DLGK_GRID_UP, KEY_UP ),
DLG_KEYS_DATA( DLGK_GRID_UP, DLGK_MOUSE(KEY_PPAGE) ),
END_KEYS_BINDING
};
/* *INDENT-ON* */
#ifdef KEY_RESIZE
int old_height = height;
int old_width = width;
#endif
BOX dy_box, mn_box, yr_box;
int fkey;
int key = 0;
int key2;
int step;
int button;
int result = DLG_EXIT_UNKNOWN;
WINDOW *dialog;
time_t now_time = time((time_t *) 0);
struct tm current;
int state = dlg_default_button();
const char **buttons = dlg_ok_labels();
char *prompt = dlg_strclone(subtitle);
int mincols = MIN_WIDE;
char buffer[MAX_LEN];
DIALOG_VARS save_vars;
dlg_save_vars(&save_vars);
dialog_vars.separate_output = TRUE;
dlg_does_output();
now_time = time((time_t *) 0);
current = *localtime(&now_time);
if (day < 0)
day = current.tm_mday;
if (month < 0)
month = current.tm_mon + 1;
if (year < 0)
year = current.tm_year + 1900;
/* compute a struct tm that matches the day/month/year parameters */
if (((year -= 1900) > 0) && (year < 200)) {
/* ugly, but I'd like to run this on older machines w/o mktime -TD */
for (;;) {
if (year > current.tm_year) {
now_time += ONE_DAY * days_in_year(¤t, 0);
} else if (year < current.tm_year) {
now_time -= ONE_DAY * days_in_year(¤t, -1);
} else if (month > current.tm_mon + 1) {
now_time += ONE_DAY * days_in_month(¤t, 0);
} else if (month < current.tm_mon + 1) {
now_time -= ONE_DAY * days_in_month(¤t, -1);
} else if (day > current.tm_mday) {
now_time += ONE_DAY;
} else if (day < current.tm_mday) {
now_time -= ONE_DAY;
} else {
break;
}
current = *localtime(&now_time);
}
}
dlg_button_layout(buttons, &mincols);
#ifdef KEY_RESIZE
retry:
#endif
dlg_auto_size(title, prompt, &height, &width, 0, mincols);
height += MIN_HIGH - 1;
dlg_print_size(height, width);
dlg_ctl_size(height, width);
dialog = dlg_new_window(height, width,
dlg_box_y_ordinate(height),
dlg_box_x_ordinate(width));
dlg_register_window(dialog, "calendar", binding);
dlg_register_buttons(dialog, "calendar", buttons);
/* mainbox */
dlg_draw_box2(dialog, 0, 0, height, width, dialog_attr, border_attr, border2_attr);
dlg_draw_bottom_box2(dialog, border_attr, border2_attr, dialog_attr);
dlg_draw_title(dialog, title);
(void) wattrset(dialog, dialog_attr); /* text mainbox */
dlg_print_autowrap(dialog, prompt, height, width);
/* compute positions of day, month and year boxes */
memset(&dy_box, 0, sizeof(dy_box));
memset(&mn_box, 0, sizeof(mn_box));
memset(&yr_box, 0, sizeof(yr_box));
if (init_object(&dy_box,
dialog,
(width - DAY_WIDE) / 2,
1 + (height - (DAY_HIGH + BTN_HIGH + (5 * MARGIN))),
DAY_WIDE,
DAY_HIGH + 1,
draw_day,
'D') < 0
|| DrawObject(&dy_box) < 0) {
return CleanupResult(DLG_EXIT_ERROR, dialog, prompt, &save_vars);
}
if (init_object(&mn_box,
dialog,
dy_box.x,
dy_box.y - (HDR_HIGH + 2 * MARGIN),
(DAY_WIDE / 2) - MARGIN,
HDR_HIGH,
draw_month,
'M') < 0
|| DrawObject(&mn_box) < 0) {
return CleanupResult(DLG_EXIT_ERROR, dialog, prompt, &save_vars);
}
if (init_object(&yr_box,
dialog,
dy_box.x + mn_box.width + 2,
mn_box.y,
mn_box.width,
mn_box.height,
draw_year,
'Y') < 0
|| DrawObject(&yr_box) < 0) {
return CleanupResult(DLG_EXIT_ERROR, dialog, prompt, &save_vars);
}
dlg_trace_win(dialog);
while (result == DLG_EXIT_UNKNOWN) {
BOX *obj = (state == sDAY ? &dy_box
: (state == sMONTH ? &mn_box :
(state == sYEAR ? &yr_box : 0)));
button = (state < 0) ? 0 : state;
dlg_draw_buttons(dialog, height - 2, 0, buttons, button, FALSE, width);
if (obj != 0)
dlg_set_focus(dialog, obj->window);
key = dlg_mouse_wgetch(dialog, &fkey);
if (dlg_result_key(key, fkey, &result))
break;
if (fkey && (key >= DLGK_MOUSE(KEY_MIN) && key <= DLGK_MOUSE(KEY_MAX))) {
key = dlg_lookup_key(dialog, key - M_EVENT, &fkey);
}
if ((key2 = dlg_char_to_button(key, buttons)) >= 0) {
result = key2;
} else if (fkey) {
/* handle function-keys */
switch (key) {
case DLGK_MOUSE('D'):
state = sDAY;
break;
case DLGK_MOUSE('M'):
state = sMONTH;
break;
case DLGK_MOUSE('Y'):
state = sYEAR;
break;
case DLGK_ENTER:
result = dlg_enter_buttoncode(button);
break;
case DLGK_FIELD_PREV:
state = dlg_prev_ok_buttonindex(state, sMONTH);
break;
case DLGK_FIELD_NEXT:
state = dlg_next_ok_buttonindex(state, sMONTH);
break;
#ifdef KEY_RESIZE
case KEY_RESIZE:
/* reset data */
height = old_height;
width = old_width;
/* repaint */
dlg_clear();
dlg_del_window(dialog);
refresh();
dlg_mouse_free_regions();
goto retry;
#endif
default:
step = 0;
key2 = -1;
if (is_DLGK_MOUSE(key)) {
if ((key2 = dlg_ok_buttoncode(key - M_EVENT)) >= 0) {
result = key2;
break;
} else if (key >= DLGK_MOUSE(KEY_MAX)) {
state = sDAY;
obj = &dy_box;
key2 = 1;
step = (key
- DLGK_MOUSE(KEY_MAX)
- day_cell_number(¤t));
}
}
if (obj != 0) {
if (key2 < 0)
step = next_or_previous(key, (obj == &dy_box));
if (step != 0) {
struct tm old = current;
/* see comment regarding mktime -TD */
if (obj == &dy_box) {
now_time += ONE_DAY * step;
} else if (obj == &mn_box) {
if (step > 0)
now_time += ONE_DAY *
days_in_month(¤t, 0);
else
now_time -= ONE_DAY *
days_in_month(¤t, -1);
} else if (obj == &yr_box) {
if (step > 0)
now_time += (ONE_DAY
* days_in_year(¤t, 0));
else
now_time -= (ONE_DAY
* days_in_year(¤t, -1));
}
current = *localtime(&now_time);
if (obj != &dy_box
&& (current.tm_mday != old.tm_mday
|| current.tm_mon != old.tm_mon
|| current.tm_year != old.tm_year))
DrawObject(&dy_box);
if (obj != &mn_box && current.tm_mon != old.tm_mon)
DrawObject(&mn_box);
if (obj != &yr_box && current.tm_year != old.tm_year)
DrawObject(&yr_box);
(void) DrawObject(obj);
}
} else if (state >= 0) {
if (next_or_previous(key, FALSE) < 0)
state = dlg_prev_ok_buttonindex(state, sMONTH);
else if (next_or_previous(key, FALSE) > 0)
state = dlg_next_ok_buttonindex(state, sMONTH);
}
break;
}
}
}
#define DefaultFormat(dst, src) \
sprintf(dst, "%02d/%02d/%0d", \
src.tm_mday, src.tm_mon + 1, src.tm_year + 1900)
#ifdef HAVE_STRFTIME
if (dialog_vars.date_format != 0) {
size_t used = strftime(buffer,
sizeof(buffer) - 1,
dialog_vars.date_format,
¤t);
if (used == 0 || *buffer == '\0')
DefaultFormat(buffer, current);
} else
#endif
DefaultFormat(buffer, current);
dlg_add_result(buffer);
dlg_add_separator();
return CleanupResult(result, dialog, prompt, &save_vars);
}
void XMLCALL XMLParser::startElement(void *data, const XML_Char* element, const XML_Char** attrs) {
// order in the following "if" statements is based on frequency of tags in planet file
if (!strcmp(element, "nd")) {
for (int count = 0; attrs[count]; count += 2) {
if (!strcmp(attrs[count], "ref")) {
way->add_node(atoll(attrs[count+1]));
}
}
}
else if (!strcmp(element, "node")) {
init_object(data, node, attrs);
}
else if (!strcmp(element, "tag")) {
const char *key = "", *value = "";
for (int count = 0; attrs[count]; count += 2) {
if (attrs[count][0] == 'k' && attrs[count][1] == 0) {
key = attrs[count+1];
}
if (attrs[count][0] == 'v' && attrs[count][1] == 0) {
value = attrs[count+1];
}
}
// XXX assert key, value exist
if (OBJECT) {
OBJECT->add_tag(key, value);
}
}
else if (!strcmp(element, "way")) {
if (last_object_type != WAY) {
if (callbacks->after_nodes) { callbacks->after_nodes(); }
last_object_type = WAY;
if (callbacks->before_ways) { callbacks->before_ways(); }
}
init_object(data, way, attrs);
}
else if (!strcmp(element, "member")) {
char type = 'x';
uint64_t ref = 0;
const char *role = "";
for (int count = 0; attrs[count]; count += 2) {
if (!strcmp(attrs[count], "type")) {
type = (char)attrs[count+1][0];
}
else if (!strcmp(attrs[count], "ref")) {
ref = atoll(attrs[count+1]);
}
else if (!strcmp(attrs[count], "role")) {
role = (char *)attrs[count+1];
}
}
// XXX assert type, ref, role are set
relation->add_member(type, ref, role);
}
else if (!strcmp(element, "relation")) {
if (last_object_type != RELATION) {
if (callbacks->after_ways) { callbacks->after_ways(); }
last_object_type = RELATION;
if (callbacks->before_relations) { callbacks->before_relations(); }
}
init_object(data, relation, attrs);
}
}
