gint display_one_judoka(struct judoka *j)
{
GtkTreeIter iter, parent, child;
struct judoka *parent_data;
guint ret = -1;
if (j->visible == FALSE) {
/* category row */
if (find_iter(&iter, j->index)) {
/* existing category */
put_data_by_iter(j, &iter);
return -1;
}
return set_category(&parent, j->index, (gchar *)j->last,
j->belt, j->birthyear, j->deleted);
}
if (find_iter(&iter, j->index)) {
/* existing judoka */
if (gtk_tree_model_iter_parent((GtkTreeModel *)current_model, &parent, &iter) == FALSE) {
/* illegal situation */
g_print("ILLEGAL\n");
if (j->category)
ret = set_category(&parent, 0,
(gchar *)j->category,
0, 0, 0);
}
parent_data = get_data_by_iter(&parent);
if (j->category && strcmp(parent_data->last, j->category)) {
/* category has changed */
gtk_tree_store_remove((GtkTreeStore *)current_model, &iter);
ret = set_category(&parent, 0, (gchar *)j->category, 0, 0, 0);
gtk_tree_store_append((GtkTreeStore *)current_model,
&iter, &parent);
put_data_by_iter(j, &iter);
} else {
/* current row is ok */
put_data_by_iter(j, &iter);
}
free_judoka(parent_data);
} else {
/* new judoka */
ret = set_category(&parent, 0, (gchar *)j->category, 0, 0, 0);
gtk_tree_store_append((GtkTreeStore *)current_model,
&child, &parent);
put_data_by_iter(j, &child);
}
return ret;
}
Token :: Token(char input, Category category, double actual_value, int precedence)
{
set_input(input);
set_category(category);
set_actual_value(actual_value);
set_precedence(precedence);
}
int
main(int argc, char *argv[]) {
prog = argv[0];
fps_flag = (getenv("FPS") != NULL);
load_config("lsc");
init_font_locale(lookup("locale", 0, 0));
srandom(0);
set_screen_size(SCREEN_WIDTH, SCREEN_HEIGHT);
layout_screen();
init_polar();
init_transforms();
init_video_in();
init_display(argc, argv, prog);
set_category(primary_buttons[Cat_change_color].b);
gettimeofday(&last_busy, 0);
ARGBEGIN {
case 'd': debug++; break;
case 'g': grabtimeout = atoi(ARGF()); break;
case 'i': idletime = atoi(ARGF()); break;
default:
return usage();
} ARGEND;
if (grabtimeout != 0 && grabtimeout < ALARMTIME) {
fprintf(stderr, "unreasonable grab time limit\n");
exit(14);
}
state = Live;
io_main_loop();
return 0;
}
/**
* \brief Constructor.
*/
ptb::gorilla::gorilla()
: m_progress(NULL), m_want_come_back(false), m_scan_distance(320)
{
set_z_fixed(false);
set_mass(100);
set_density(2);
m_monster_type = monster::enemy_monster;
m_energy = 30;
m_offensive_phase = true;
m_offensive_force = s_gorilla_offensive_force;
m_offensive_coefficients[normal_attack] = 1;
get_rendering_attributes().mirror(false);
set_category("gorilla");
} // gorilla::gorilla()
int
process_command(Point mouse) {
button *bp = buttons;
while (bp && (bp->state == Hidden || !ptinrect(mouse, bp->r)))
bp = bp->next;
if (!bp)
return 0;
if (bp == undo_button) {
if (nhist > 0) {
nhist--;
show_hist();
}
} else if (bp == startover_button) {
unfreeze();
nhist = 0;
show_hist();
} else if (bp == freeze_button) {
switch (state) {
case Live:
state = Frozen;
freeze_button->state = On;
paint_fancy_button(freeze_button);
break;
case Frozen:
unfreeze();
break;
default:
break;
}
flush_screen();
} else if (bp == primary_buttons[Cat_change_color].b ||
bp == primary_buttons[Cat_change_look].b ||
bp == primary_buttons[Cat_change_shape].b) {
set_category(bp);
} else {
if (bp && nhist < MAXHIST) {
history[nhist++] = bp;
show_hist();
}
}
flush_screen();
return 1;
}
/*
* Draw the current screen.
*/
void
draw_screen(void) {
button *bp = buttons;
clear_screen_to_background();
while (bp) {
if (bp->state != Hidden && bp->category == Cat_none) {
paint_fancy_button(bp);
flush_screen();
}
bp = bp->next;
}
set_category(current_primary_button);
show_hist();
write_video_frame_zoom(video_r.min, &frames[nhist], VIDEO_ZOOM);
show_cursor();
flush_screen();
}
/*
* Main thread. Sits on the message queue and waits for something to do.
*
* The transport thread for the ibm will issue a delayed request for
* requests supporting delayed requests. Otherwise will issue the request
* and wait for response.
*/
void *
transport_thread(
void *vxport)
{
robo_event_t *event;
xport_state_t *transport = (xport_state_t *)vxport;
struct sigaction sig_action;
sigset_t signal_set, full_block_set;
sigfillset(&full_block_set);
sigemptyset(&signal_set); /* signals to except. */
sigaddset(&signal_set, SIGCHLD);
mutex_lock(&transport->mutex); /* wait for go */
mutex_unlock(&transport->mutex);
l_mess = transport->library->un->dis_mes[DIS_MES_NORM];
lc_mess = transport->library->un->dis_mes[DIS_MES_CRIT];
thr_sigsetmask(SIG_SETMASK, &full_block_set, NULL);
memset(&sig_action, 0, sizeof (struct sigaction));
(void) sigemptyset(&sig_action.sa_mask);
sig_action.sa_flags = SA_RESTART;
sig_action.sa_handler = SIG_DFL;
(void) sigaction(SIGCHLD, &sig_action, NULL);
for (;;) {
mutex_lock(&transport->list_mutex);
if (transport->active_count == 0)
cond_wait(&transport->list_condit,
&transport->list_mutex);
if (transport->active_count == 0) { /* check to make sure */
mutex_unlock(&transport->list_mutex);
continue;
}
event = transport->first;
transport->first = unlink_list(event);
transport->active_count--;
mutex_unlock(&transport->list_mutex);
ETRACE((LOG_NOTICE, "EvTr %#x(%#x) - \n",
event, (event->type == EVENT_TYPE_MESS) ?
event->request.message.command :
event->request.internal.command));
event->next = NULL;
/* Everyone must take care of disposing of the event */
switch (event->type) {
case EVENT_TYPE_INTERNAL:
switch (event->request.internal.command) {
case ROBOT_INTRL_LOAD_MEDIA:
if (transport->library->un->state <= DEV_IDLE) {
load(transport->library, event);
} else {
disp_of_event(transport->library,
event, EINVAL);
}
break;
case ROBOT_INTRL_FORCE_MEDIA:
force(transport->library, event);
break;
case ROBOT_INTRL_DISMOUNT_MEDIA:
dismount(transport->library, event);
break;
case ROBOT_INTRL_INIT:
init_transport(transport);
disp_of_event(transport->library, event, 0);
break;
case ROBOT_INTRL_VIEW_DATABASE:
view(transport->library, event);
break;
case ROBOT_INTRL_QUERY_DRIVE:
query_drv(transport->library, event);
break;
case ROBOT_INTRL_QUERY_LIBRARY:
query_lib(transport->library, event);
break;
case ROBOT_INTRL_SET_CATEGORY:
set_category(transport->library, event);
break;
case ROBOT_INTRL_SHUTDOWN:
transport->thread = (thread_t)- 1;
thr_exit((void *)NULL);
break;
default:
disp_of_event(transport->library, event,
EINVAL);
break;
}
break;
case EVENT_TYPE_MESS:
if (event->request.message.magic != MESSAGE_MAGIC) {
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:bad magic: %s:%d.\n",
__FILE__, __LINE__);
disp_of_event(transport->library, event,
EINVAL);
break;
}
switch (event->request.message.command) {
default:
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:msq_bad: %s:%d.\n",
__FILE__, __LINE__);
disp_of_event(transport->library, event,
EINVAL);
break;
}
default:
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:event_bad: %s:%d.\n",
__FILE__, __LINE__);
disp_of_event(transport->library, event, EINVAL);
break;
}
}
}
