void workbook_serializer::read_properties_core(const xml_document &xml)
{
auto &props = workbook_.get_properties();
auto root_node = xml.get_child("cp:coreProperties");
props.excel_base_date = calendar::windows_1900;
if (root_node.has_child("dc:creator"))
{
props.creator = root_node.get_child("dc:creator").get_text();
}
if (root_node.has_child("cp:lastModifiedBy"))
{
props.last_modified_by = root_node.get_child("cp:lastModifiedBy").get_text();
}
if (root_node.has_child("dcterms:created"))
{
std::string created_string = root_node.get_child("dcterms:created").get_text();
props.created = w3cdtf_to_datetime(created_string);
}
if (root_node.has_child("dcterms:modified"))
{
std::string modified_string = root_node.get_child("dcterms:modified").get_text();
props.modified = w3cdtf_to_datetime(modified_string);
}
}
void abstract_group::replace_child(server_node * node, server_node * node_to_replace)
{
assert (not has_child(node));
assert (has_child(node_to_replace));
server_node_list::iterator position_of_old_element = server_node_list::s_iterator_to(*node_to_replace);
child_nodes.insert(position_of_old_element, *node);
node->set_parent(this);
remove_child(node_to_replace);
}
/*
* Draw the skill tree
*/
void print_skills(s32b **table, s32b max, s32b sel, s32b start)
{
s32b i, j;
s32b wid, hgt;
cptr keys;
Term_clear();
Term_get_size(&wid, &hgt);
c_prt(TERM_WHITE, format("%s Skills Screen", game_module), 0, 28);
keys = format("#BEnter#W to develop a branch, #Bup#W/#Bdown#W to move, #Bright#W/#Bleft#W to modify, #B?#W for help");
display_message(0, 1, strlen(keys), TERM_WHITE, keys);
c_prt((p_ptr->skill_points) ? TERM_L_BLUE : TERM_L_RED,
format("Skill points left: %d", p_ptr->skill_points), 2, 0);
print_desc_aux(s_info[table[sel][0]].desc, 3, 0);
for (j = start; j < start + (hgt - 7); j++)
{
byte color = TERM_WHITE;
char deb = ' ', end = ' ';
if (j >= max) break;
i = table[j][0];
if (get_skill(i) == 0)
{
if (s_info[i].mod == 0) color = TERM_L_DARK;
else color = TERM_ORANGE;
}
else if (get_skill_raw(i) == SKILL_MAX) color = TERM_L_BLUE;
if (s_info[i].hidden) color = TERM_L_RED;
if (j == sel)
{
color = TERM_L_GREEN;
deb = '[';
end = ']';
}
if (!has_child(i))
{
c_prt(color, format("%c.%c%s", deb, end, s_info[i].name),
j + 7 - start, table[j][1] * 4);
}
else if (s_info[i].dev)
{
c_prt(color, format("%c-%c%s", deb, end, s_info[i].name),
j + 7 - start, table[j][1] * 4);
}
else
{
c_prt(color, format("%c+%c%s", deb, end, s_info[i].name),
j + 7 - start, table[j][1] * 4);
}
c_prt(color,
format("%c%02ld.%03ld [%01d.%03d]", (get_skill_raw(i) < 0) ? '-' : ' ',
abs(get_skill_raw(i)) / SKILL_STEP, abs(get_skill_raw(i)) % SKILL_STEP,
s_info[i].mod / 1000, s_info[i].mod % 1000),
j + 7 - start, 60);
}
}
void abstract_group::add_child(server_node * node)
{
assert (not has_child(node));
child_nodes.push_front(*node);
node->set_parent(this);
}
typename tree< T , A >::const_iterator
tree< T , A >::get_child( const_iterator it ) const
{
if ( ! has_child( it ) )
return const_iterator( root_ );
return const_iterator( get_node_ptr( it )->child );
}
server_node * previous_node(server_node * node)
{
assert(has_child(node));
server_node_list::iterator it = server_node_list::s_iterator_to(*node);
if (unlikely(it == child_nodes.begin()))
return nullptr;
else
return &(*--it);
}
server_node * next_node(server_node * node)
{
assert(has_child(node));
server_node_list::iterator next = ++server_node_list::s_iterator_to(*node);
if (unlikely(next == child_nodes.end()))
return nullptr;
else
return &(*next);
}
void group::add_child(server_node * node, node_position position)
{
assert (not has_child(node));
assert((position == head) || (position == tail));
if (position == head)
child_nodes.push_front(*node);
else
child_nodes.push_back(*node);
node->set_parent(this);
}
static bool has_child(LayerGroup* parent, Layer* child)
{
for (auto c : parent->layers()) {
if (c == child)
return true;
else if (c->isGroup() &&
has_child(static_cast<LayerGroup*>(c), child))
return true;
}
return false;
}
bst_t bst_remove(bst_t bst, index_t index) {
if (bst_type(bst) == isNotEmpty) {
switch (index_compare(index, bst)) {
case EQ:
switch (has_child(bst)) {
case none:
bst = bst_destroy(bst);
break;
case both:
case justRigth:
pair_destroy(bst->pair);
bst->pair = pair_copy((bst->der)->pair); /*copia el par q le sigue (der) */
bst->der =
bst_remove(bst->der, pair_fst((bst->der)->pair));
break;
case justLeft:
pair_destroy(bst->pair);
bst->pair = pair_copy((bst->izq)->pair); /*copia el par q le sigue (der) */
bst->izq =
bst_remove(bst->izq, pair_fst((bst->izq)->pair));
break;
}
break;
case LT:
bst->izq = bst_remove(bst->izq, index);
break;
case GT:
bst->der = bst_remove(bst->der, index);
break;
}
}
return (bst);
}
/*
* Dump the skill tree
*/
void dump_skills(PHYSFS_file *fff)
{
s32b i, j, max = 0;
s32b **table;
char buf[80];
C_MAKE(table, max_s_idx, s32b*);
for (i = 0; i < max_s_idx; i++) C_MAKE(table[i], 2, s32b);
init_table(table, &max, TRUE);
fprintf(fff, "\nSkills (points left: %d)", p_ptr->skill_points);
for (j = 0; j < max; j++)
{
s32b z;
i = table[j][0];
if (get_skill(i) == 0)
{
if (s_info[i].mod == 0) continue;
}
sprintf(buf, "\n");
for (z = 0; z < table[j][1]; z++) strcat(buf, " ");
if (!has_child(i))
{
strcat(buf, format(" . %s", s_info[i].name));
}
else
{
strcat(buf, format(" - %s", s_info[i].name));
}
fprintf(fff, "%-50s%c%02ld.%03ld [%01d.%03d]", buf, (get_skill_raw(i) < 0) ? '-' : ' ',
abs(get_skill_raw(i)) / SKILL_STEP, abs(get_skill_raw(i)) % SKILL_STEP,
s_info[i].mod / 1000, s_info[i].mod % 1000);
}
fprintf(fff, "\n");
for (i = 0; i < max_s_idx; i++) C_FREE(table[i], 2, s32b);
C_FREE(table, max_s_idx, s32b*);
}
void group::add_child(server_node * node, node_position_constraint const & constraint)
{
assert (not has_child(node));
server_node * ref = constraint.first;
node_position position = constraint.second;
assert ((position == after) ||
(position == before) ||
(position == insert));
server_node_list::const_iterator it = child_nodes.iterator_to(*ref);
if (position == after)
++it;
child_nodes.insert(it, *node);
node->set_parent(this);
}
/**
*Returns true if the dict contains the given word.
*Checks if root has a child matching the first letter in word, then if so
*checks whether the node matching the first letter has a child matching the
*secondletter, and so forth.
*
*performance is O(length_of_alphabet*length_of_longest_word)
*/
int contains(struct TreeNode *dict, char *word)
{
if(*word == '\n')//end of the word
{
return has_child(dict, word);
}
else
{
struct ListNode *chirruns = dict->children;
int found = 0;
while(chirruns != NULL && !found)
{
if(chirruns->data->letter == *word) found = 42;
else chirruns = chirruns->next;
}
if (chirruns == NULL) return 0;
else return contains(chirruns->data, word+1);
}
}
/*
* Dump the skill tree
*/
void dump_skills(FILE *fff)
{
int i, j, max = 0;
int table[MAX_SKILLS][2];
char buf[80];
init_table(table, &max, TRUE);
fprintf(fff, "\nSkills (points left: %d)", p_ptr->skill_points);
for (j = 0; j < max; j++)
{
int z;
i = table[j][0];
if ((s_info[i].value == 0) && (i != SKILL_MISC))
{
if (s_info[i].mod == 0) continue;
}
sprintf(buf, "\n");
for (z = 0; z < table[j][1]; z++) strcat(buf, " ");
if (!has_child(i))
{
strcat(buf, format(" . %s", s_info[i].name + s_name));
}
else
{
strcat(buf, format(" - %s", s_info[i].name + s_name));
}
fprintf(fff, "%-49s%s%02ld.%03ld [%01d.%03d]",
buf, s_info[i].value < 0 ? "-" : " ",
ABS(s_info[i].value) / SKILL_STEP,
ABS(s_info[i].value) % SKILL_STEP,
s_info[i].mod / 1000, s_info[i].mod % 1000);
}
fprintf(fff, "\n");
}
bool QuadTree::insert(Entity * e) {
if(in_node(e->pos)) {
if(entity == e && e->node == this) {
return true;
}
if(entity == nullptr) {
//Has no children
if(!has_child()) {
entity = e;
e->node = this;
return true;
} else {
subdivide(in_quad(e->pos) - 1);
return children[in_quad(e->pos) - 1]->insert(e);
}
}
Entity * tmp = entity;
entity = nullptr;
subdivide(in_quad(e->pos) - 1);
subdivide(in_quad(tmp->pos) - 1);
//TODO should never happen
if(!children[in_quad(e->pos) - 1]->insert(e)) {
std::cerr << "Something is very wrong! " << std::endl;
std::cerr << "size: " << size << std::endl;
std::cerr << "child size: " << children[in_quad(tmp->pos) - 1]->size << std::endl;
}
//TODO should never happen
if(!children[in_quad(tmp->pos) - 1]->insert(tmp)) {
std::cerr << "Something is very wrong 2! " << std::endl;
std::cerr << "size: " << size << std::endl;
std::cerr << "child size: " << children[in_quad(tmp->pos) - 1]->size << std::endl;
}
return true;
}
return false;
}
void handle_event(XEvent *ev) {
client *c = owner(ev->xany.window);
#ifdef DEBUG_EVENTS
if(ev->type != Expose && ev->type != MotionNotify && !(ev->type == ConfigureNotify && ev->xconfigure.window != root)) /* this makes the output slightly more manageable */
printf(NAME ": handle_event(): got %s\n\twindow: 0x%X (%s)\n", event_name(ev), (unsigned int) ev->xany.window, c ? c->name : ((ev->xany.window == root) ? "root" : "unknown"));
#endif
if((evh && evh(ev)) || button_handle_event(ev) || ewmh_handle_event(ev) || screens_handle_event(ev)) {
#ifdef DEBUG_EVENTS
if(ev->type != Expose && ev->type != MotionNotify && (ev->type != ConfigureNotify && ev->xconfigure.window != root))
printf(NAME ": handle_event(): external event handler claimed last event\n");
#endif
return;
}
if(c) {
if(!has_child(c->parent, c->window) && ev->type != DestroyNotify && ev->type != UnmapNotify)
return;
switch(ev->type) {
case UnmapNotify:
if(c->window == ev->xunmap.window) {
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling UnmapNotify event\n\twindow: 0x%X (%s)\n", (unsigned int) c->window, c->name);
#endif
if(has_child(c->parent, c->window)) {
client_deparent(c);
set_wm_state(c->window, WithdrawnState);
}
client_remove(c);
ewmh_update_clist();
}
return;
case PropertyNotify:
if(ev->xproperty.atom == XA_WM_NAME) {
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling PropertyNotify event\n\twindow: 0x%X (%s)\n\tproperty: XA_WM_NAME\n", (unsigned int) c->window, c->name);
#endif
if(c->name != no_title)
XFree(c->name);
#ifdef USE_XFT
if(xftfont)
XftDrawDestroy(c->title_draw);
#endif
XFreePixmap(dpy, c->title_pixmap);
XFetchName(dpy, c->window, &c->name);
client_update_name(c);
XClearWindow(dpy, c->title);
if(evh == wlist_handle_event) {
XClearWindow(dpy, c->wlist_item);
wlist_item_draw(c);
}
}
if(ev->xproperty.atom == XA_WM_NORMAL_HINTS) {
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling PropertyNotify event\n\twindow: 0x%X (%s)\n\tproperty: XA_WM_NORMAL_HINTS\n", (unsigned int) c->window, c->name);
#endif
get_normal_hints(c);
}
return;
case ClientMessage:
if(ev->xclient.message_type == xa_wm_change_state && ev->xclient.data.l[0] == IconicState) {
#ifdef DEBUG_EVENTS
printf(NAME ": handling ClientMessage event\n\twindow: 0x%X (%s)\n", (unsigned int) c->window, c->name);
#endif
client_iconify(c);
return;
}
break; /* we might later need this event */
case EnterNotify:
if(c != current && !(c->flags & CLICK_FOCUS) && !click_focus && ev->xcrossing.mode != NotifyGrab && ev->xcrossing.mode != NotifyUngrab && ev->xcrossing.detail != NotifyInferior && (ev->xcrossing.window == c->parent || ev->xcrossing.window == c->wlist_item) && ev->xcrossing.send_event == False) {
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling EnterNotify event\n\twindow: 0x%X (%s)\n", (unsigned int) c->window, c->name);
#endif
client_focus(c, true);
}
return;
case Expose:
if(ev->xexpose.count == 0 && evh == wlist_handle_event && c && ev->xexpose.window == c->wlist_item)
wlist_item_draw(c);
return;
case ButtonPress:
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling ButtonPress event\n\twindow: 0x%X (%s)\n", (unsigned int) c->window, c->name);
#endif
if(c != current)
client_focus(c, true);
XAllowEvents(dpy, ReplayPointer, CurrentTime);
if(ev->xbutton.window != c->window) {
if(lastclick + doubleclick_time > ev->xbutton.time && lastbutton == ev->xbutton.button && lastclick_client == c) {
client_action(c, buttonaction(ev->xbutton.button, true), ev);
lastclick = 0;
lastclick_client = NULL;
lastbutton = None;
return;
}
lastclick = ev->xbutton.time;
lastclick_client = c;
lastbutton = ev->xbutton.button;
client_action(c, buttonaction(ev->xbutton.button, false), ev);
} else if(click_raise)
client_raise(c);
return;
case FocusIn: /* we ignore pointer events, these happen if the input focus is on the root window */
if(allow_focus_stealing && c != current && ev->xfocus.mode != NotifyGrab && ev->xfocus.mode != NotifyUngrab && ev->xfocus.detail != NotifyPointer) {
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling FocusIn event\n\twindow: 0x%X (%s)\n", (unsigned int) c->window, c->name);
#endif
client_focus(c, false);
}
return;
case FocusOut:
if(c == current && ev->xfocus.mode != NotifyGrab && ev->xfocus.mode != NotifyUngrab && ev->xfocus.detail != NotifyInferior) {
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling FocusOut event\n\twindow: 0x%X (%s)\n", (unsigned int) c->window, c->name);
#endif
if(allow_focus_stealing && ev->xfocus.detail != NotifyAncestor) {
#ifdef DEBUG_EVENTS
printf("\tfocus lost\n");
#endif
client_focus(NULL, false); /* we do this so windows that aren't managed can take focus */
} else {
#ifdef DEBUG_EVENTS
printf("\tre-focussing this window\n");
#endif
take_focus(c);
}
}
return;
#ifdef USE_SHAPE
default:
if(ev->type == shape_event) {
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling ShapeNotify event\n\twindow 0x%X (%s)\n", (unsigned int) c->window, c->name);
#endif
set_shape(c);
return;
}
#endif
}
}
switch(ev->type) {
case MapRequest:
c = owner(ev->xmaprequest.window);
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling MapRequest event\n\twindow: 0x%X (%s)\n", (unsigned int) ev->xmaprequest.window, c ? c->name : "unknown");
#endif
if(c) {
if(c->flags & ICONIC && has_child(c->parent, c->window)) {
client_restore(c);
if(focus_new)
client_focus(c, true);
}
} else if(has_child(root, ev->xmaprequest.window))
client_add(ev->xmaprequest.window, false);
return;
case DestroyNotify:
c = owner(ev->xdestroywindow.window);
if(c)
if(c->window == ev->xdestroywindow.window) {
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling DestroyNotify event\n\twindow 0x%X (%s)\n", (unsigned int) c->window, c->name);
#endif
client_remove(c);
}
return;
case ConfigureRequest:
c = owner(ev->xconfigurerequest.window);
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling ConfigureRequest event\n\twindow 0x%X (%s)\n", (unsigned int) ev->xconfigurerequest.window, c ? c->name : "unknown");
#endif
if(correct_center)
screens_correct_center(&ev->xconfigurerequest.x, &ev->xconfigurerequest.y, &ev->xconfigurerequest.width, &ev->xconfigurerequest.height);
if(c) {
if(!has_child(c->parent, c->window))
return;
if(ev->xconfigurerequest.value_mask & CWX)
c->x = ev->xconfigurerequest.x - gxo(c, false);
if(ev->xconfigurerequest.value_mask & CWY)
c->y = ev->xconfigurerequest.y - gyo(c, false);
if(ev->xconfigurerequest.value_mask & CWWidth)
c->width = ev->xconfigurerequest.width;
if(ev->xconfigurerequest.value_mask & CWHeight)
c->height = ev->xconfigurerequest.height;
client_update(c);
#ifdef DEBUG
printf(NAME ": handle_event(): reconfigured client 0x%X (%s) to %ix%i+%i+%i\n", (unsigned int) c->window, c->name, c->width, c->height, c->x, c->y);
#endif
} else if(has_child(root, ev->xconfigurerequest.window)) {
XWindowChanges wc;
wc.sibling = ev->xconfigurerequest.above;
wc.stack_mode = ev->xconfigurerequest.detail;
wc.x = ev->xconfigurerequest.x;
wc.y = ev->xconfigurerequest.y;
wc.width = ev->xconfigurerequest.width;
wc.height = ev->xconfigurerequest.height;
XConfigureWindow(dpy, ev->xconfigurerequest.window, ev->xconfigurerequest.value_mask, &wc);
}
return;
case MapNotify:
if(correct_center_unmanaged && ev->xany.window == root && !owner(ev->xmap.window)) {
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling MapNotify event\n\twindow 0x%X (unknown)\n", (unsigned int) ev->xmap.window);
#endif
window_correct_center(ev->xmap.window);
}
return;
case MappingNotify:
if(ev->xmapping.request != MappingPointer) {
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling MappingNotify event\n");
#endif
keys_ungrab();
XRefreshKeyboardMapping(&ev->xmapping);
keys_update();
}
return;
case KeyPress:
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling KeyPress event\n");
#endif
client_action(current, keyaction(ev), ev);
return;
case ButtonPress:
if(ev->xbutton.window != root)
return;
#ifdef DEBUG_EVENTS
printf(NAME ": handle_event(): handling ButtonPress event\n");
#endif
if(lastclick + doubleclick_time > ev->xbutton.time && lastbutton == ev->xbutton.button && lastclick_client == NULL) {
client_action(current, root_buttonaction(ev->xbutton.button, true), ev);
lastclick = 0;
lastclick_client = NULL;
lastbutton = None;
return;
}
lastclick = ev->xbutton.time;
lastclick_client = NULL;
lastbutton = ev->xbutton.button;
client_action(current, root_buttonaction(ev->xbutton.button, false), ev);
return;
case ClientMessage:
if(ev->xclient.message_type == xa_internal_message) {
if(((Atom) ev->xclient.data.l[0]) == xa_quit) {
#ifdef DEBUG
printf(NAME ": handle_event(): quit message received\n");
#endif
exit(0);
}
if(((Atom) ev->xclient.data.l[0]) == xa_reinit) {
#ifdef DEBUG
printf(NAME ": handle_event(): reinitialize message received\n");
#endif
cfg_reinitialize();
}
}
}
}
void abstract_group::remove_child(server_node * node)
{
assert (has_child(node));
node->server_node::parent_hook::unlink();
node->clear_parent();
}
static void print_all(s32b **table, s32b max, s32b table_ab[], s32b max_ab, s32b sel, s32b start)
{
s32b i, j;
s32b wid, hgt;
cptr keys;
Term_clear();
Term_get_size(&wid, &hgt);
c_prt(TERM_WHITE, format("%s Skills and Abilities Screen", game_module), 0, 24);
keys = format("#BEnter#W to develop a branch, #Bup#W/#Bdown#W to move, #Bright#W/#Bleft#W to modify, #B?#W for help");
display_message(0, 1, strlen(keys), TERM_WHITE, keys);
c_prt((p_ptr->skill_points) ? TERM_L_BLUE : TERM_L_RED,
format("Skill points left: %d", p_ptr->skill_points), 2, 0);
if (sel == 0)
{
c_prt(TERM_YELLOW, "Skills represent your level of proficiency in the various fields of mastery", 3, 0);
c_prt(TERM_YELLOW, "available to your character.", 4, 0);
c_prt(TERM_YELLOW, format("Skills can naturally be raised to %ld.", SKILL_MAX / SKILL_STEP), 5, 0);
}
else if (sel == max)
{
c_prt(TERM_YELLOW, "Abilities are various traits your character may acquire. Contrary to skills", 3, 0);
c_prt(TERM_YELLOW, "abilities are on/off toggles, you either now them or not, there is no level", 4, 0);
c_prt(TERM_YELLOW, "involved.", 5, 0);
}
else if (sel < max)
print_desc_aux(s_info[table[sel-1][0]].desc, 3, 0);
else
print_desc_aux(ab_info[table_ab[sel-1 - max]].desc, 3, 0);
for (j = start; j < start + (hgt - 7); j++)
{
byte color = TERM_WHITE;
char deb = ' ', end = ' ';
if ((j == 0) && max)
{
deb = end = '-';
color = TERM_YELLOW;
if (j == sel)
{
color = TERM_ORANGE;
deb = '[';
end = ']';
}
c_prt(color, format("%c-%c---------------------------------------------------------------------- Skills", deb, end), j + 7 - start, 0);
}
else if ((j == max) && max_ab)
{
deb = end = '-';
color = TERM_YELLOW;
if (j == sel)
{
color = TERM_ORANGE;
deb = '[';
end = ']';
}
c_prt(color, format("%c-%c------------------------------------------------------------------- Abilities", deb, end), j + 7 - start, 0);
}
else if (j < max)
{
i = table[j-1][0];
if (get_skill(i) == 0)
{
if (s_info[i].mod == 0) color = TERM_L_DARK;
else color = TERM_ORANGE;
}
else if (get_skill_raw(i) == SKILL_MAX) color = TERM_L_BLUE;
if (s_info[i].hidden) color = TERM_L_RED;
if (j == sel)
{
color = TERM_L_GREEN;
deb = '[';
end = ']';
}
if (!has_child(i))
{
c_prt(color, format("%c.%c%s", deb, end, s_info[i].name),
j + 7 - start, table[j-1][1] * 4);
}
else if (s_info[i].dev)
{
c_prt(color, format("%c-%c%s", deb, end, s_info[i].name),
j + 7 - start, table[j-1][1] * 4);
}
else
{
c_prt(color, format("%c+%c%s", deb, end, s_info[i].name),
j + 7 - start, table[j-1][1] * 4);
}
c_prt(color,
format("%c%02ld.%03ld [%01d.%03d]", (get_skill_raw(i) < 0) ? '-' : ' ',
abs(get_skill_raw(i)) / SKILL_STEP, abs(get_skill_raw(i)) % SKILL_STEP,
s_info[i].mod / 1000, s_info[i].mod % 1000),
j + 7 - start, 60);
}
else
{
byte color = TERM_WHITE;
char deb = ' ', end = ' ';
if (j - max >= max_ab) break;
i = table_ab[j-1 - max];
if (ab_info[i].acquired)
color = TERM_L_BLUE;
else if (can_learn_ability(i))
color = TERM_WHITE;
else
color = TERM_L_DARK;
if (j == sel)
{
color = TERM_L_GREEN;
deb = '[';
end = ']';
}
c_prt(color, format("%c.%c%s", deb, end, ab_info[i].name),
j + 7 - start, 0);
if (!ab_info[i].acquired)
{
c_prt(color, format("%d", ab_info[i].cost), j + 7 - start, 61);
}
else
{
c_prt(color, "Known", j + 7 - start, 61);
}
}
}
}
static DocRange drop_range_op(
Doc* doc,
const Op op,
const DocRange& from,
DocRangePlace place,
const TagsHandling tagsHandling,
DocRange to)
{
// Convert "first child" operation into a insert after last child.
LayerGroup* parent = nullptr;
if (to.type() == DocRange::kLayers &&
!to.selectedLayers().empty()) {
if (place == kDocRangeFirstChild &&
(*to.selectedLayers().begin())->isGroup()) {
place = kDocRangeAfter;
parent = static_cast<LayerGroup*>((*to.selectedLayers().begin()));
to.clearRange();
to.startRange(parent->lastLayer(), -1, DocRange::kLayers);
to.endRange(parent->lastLayer(), -1);
}
else {
parent = (*to.selectedLayers().begin())->parent();
}
// Check that we're not moving a group inside itself
for (auto moveThis : from.selectedLayers()) {
if (moveThis == parent ||
(moveThis->isGroup() &&
has_child(static_cast<LayerGroup*>(moveThis), parent)))
return from;
}
}
if (place != kDocRangeBefore &&
place != kDocRangeAfter) {
ASSERT(false);
throw std::invalid_argument("Invalid 'place' argument");
}
Sprite* sprite = doc->sprite();
// Check noop/trivial/do nothing cases, i.e., move a range to the same place.
// Also check invalid cases, like moving a Background layer.
switch (from.type()) {
case DocRange::kCels:
if (from == to)
return from;
break;
case DocRange::kFrames:
if (op == Move) {
// Simple cases with one continuos range of frames that are a
// no-op.
if ((from.selectedFrames().ranges() == 1) &&
((to.firstFrame() >= from.firstFrame() &&
to.lastFrame() <= from.lastFrame()) ||
(place == kDocRangeBefore && to.firstFrame() == from.lastFrame()+1) ||
(place == kDocRangeAfter && to.lastFrame() == from.firstFrame()-1)) &&
// If there are tags, this might not be a no-op
(sprite->frameTags().empty() ||
tagsHandling == kDontAdjustTags)) {
return from;
}
}
break;
case DocRange::kLayers:
if (op == Move) {
SelectedLayers srcSelLayers = from.selectedLayers();
SelectedLayers dstSelLayers = to.selectedLayers();
LayerList srcLayers = srcSelLayers.toLayerList();
LayerList dstLayers = dstSelLayers.toLayerList();
ASSERT(!srcLayers.empty());
if (srcLayers.empty())
return from;
// dstLayers can be nullptr when we insert the first child in
// a group.
// Check no-ops when we move layers at the same level (all
// layers with the same parent), all adjacents, and which are
// moved to the same place.
if (!dstSelLayers.empty() &&
srcSelLayers.hasSameParent() &&
dstSelLayers.hasSameParent() &&
are_layers_adjacent(srcLayers) &&
are_layers_adjacent(dstLayers)) {
for (Layer* srcLayer : srcLayers)
if (dstSelLayers.contains(srcLayer))
return from;
if ((place == kDocRangeBefore
&& dstLayers.front() == srcLayers.back()->getNext()) ||
(place == kDocRangeAfter
&& dstLayers.back() == srcLayers.front()->getPrevious()))
return from;
}
// We cannot move the background
for (Layer* layer : srcSelLayers)
if (layer->isBackground())
throw std::runtime_error("The background layer cannot be moved");
}
// Before background
if (place == kDocRangeBefore) {
for (Layer* background : to.selectedLayers()) {
if (background && background->isBackground())
throw std::runtime_error("You cannot move or copy something below the background layer");
}
}
break;
}
const char* undoLabel = NULL;
switch (op) {
case Move: undoLabel = "Move Range"; break;
case Copy: undoLabel = "Copy Range"; break;
default:
ASSERT(false);
throw std::invalid_argument("Invalid 'op' argument");
}
DocRange resultRange;
{
const app::Context* context = static_cast<app::Context*>(doc->context());
const ContextReader reader(context);
ContextWriter writer(reader, 500);
Transaction transaction(writer.context(), undoLabel, ModifyDocument);
DocApi api = doc->getApi(transaction);
// TODO Try to add the range with just one call to DocApi
// methods, to avoid generating a lot of cmd::SetCelFrame (see
// DocApi::setCelFramePosition() function).
switch (from.type()) {
case DocRange::kCels: {
LayerList allLayers = sprite->allBrowsableLayers();
if (allLayers.empty())
break;
LayerList srcLayers = from.selectedLayers().toLayerList();
LayerList dstLayers = to.selectedLayers().toLayerList();
if (srcLayers.empty() ||
dstLayers.empty())
throw std::invalid_argument("You need to specify a non-empty cels range");
if (find_layer_index(allLayers, srcLayers.front()) <
find_layer_index(allLayers, dstLayers.front())) {
std::reverse(srcLayers.begin(), srcLayers.end());
std::reverse(dstLayers.begin(), dstLayers.end());
}
if (from.firstFrame() < to.firstFrame()) {
auto srcFrames = from.selectedFrames().makeReverse();
auto dstFrames = to.selectedFrames().makeReverse();
move_or_copy_cels(api, op, srcLayers, dstLayers, srcFrames, dstFrames);
}
else {
const auto& srcFrames = from.selectedFrames();
const auto& dstFrames = to.selectedFrames();
move_or_copy_cels(api, op, srcLayers, dstLayers, srcFrames, dstFrames);
}
resultRange = to;
break;
}
case DocRange::kFrames: {
frame_t dstFrame;
if (place == kDocRangeBefore)
dstFrame = to.firstFrame();
else
dstFrame = to.lastFrame();
resultRange = move_or_copy_frames(api, op, sprite,
from, dstFrame,
place, tagsHandling);
break;
}
case DocRange::kLayers: {
LayerList allLayers = sprite->allBrowsableLayers();
if (allLayers.empty())
break;
LayerList srcLayers = from.selectedLayers().toLayerList();
LayerList dstLayers = to.selectedLayers().toLayerList();
ASSERT(!srcLayers.empty());
switch (op) {
case Move:
if (place == kDocRangeBefore) {
Layer* beforeThis = (!dstLayers.empty() ? dstLayers.front(): nullptr);
Layer* afterThis = nullptr;
for (Layer* srcLayer : srcLayers) {
if (afterThis)
api.restackLayerAfter(srcLayer, parent, afterThis);
else
api.restackLayerBefore(srcLayer, parent, beforeThis);
afterThis = srcLayer;
}
}
else if (place == kDocRangeAfter) {
Layer* afterThis = (!dstLayers.empty() ? dstLayers.back(): nullptr);
for (Layer* srcLayer : srcLayers) {
api.restackLayerAfter(srcLayer, parent, afterThis);
afterThis = srcLayer;
}
}
// Same set of layers than the "from" range
resultRange = from;
break;
case Copy: {
if (place == kDocRangeBefore) {
Layer* beforeThis = (!dstLayers.empty() ? dstLayers.front(): nullptr);
for (Layer* srcLayer : srcLayers) {
Layer* copiedLayer = api.duplicateLayerBefore(
srcLayer, parent, beforeThis);
resultRange.startRange(copiedLayer, -1, DocRange::kLayers);
resultRange.endRange(copiedLayer, -1);
}
}
else if (place == kDocRangeAfter) {
std::reverse(srcLayers.begin(), srcLayers.end());
Layer* afterThis = (!dstLayers.empty() ? dstLayers.back(): nullptr);
for (Layer* srcLayer : srcLayers) {
Layer* copiedLayer = api.duplicateLayerAfter(
srcLayer, parent, afterThis);
resultRange.startRange(copiedLayer, -1, DocRange::kLayers);
resultRange.endRange(copiedLayer, -1);
}
}
break;
}
}
break;
}
}
if (resultRange.type() != DocRange::kNone)
transaction.setNewDocRange(resultRange);
transaction.commit();
}
return resultRange;
}
/*
* Draw the skill tree
*/
void print_skills(int table[MAX_SKILLS][2], int max, int sel, int start)
{
int i, j;
int wid, hgt;
cptr keys;
Term_clear();
Term_get_size(&wid, &hgt);
c_prt(TERM_WHITE, format("%s Skills Screen", game_module), 0, 28);
keys = format("#BEnter#W to develop a branch, #Bup#W/#Bdown#W to move, #Bright#W/#Bleft#W to modify, #B?#W for help");
display_message(0, 1, strlen(keys), TERM_WHITE, keys);
c_prt((p_ptr->skill_points) ? TERM_L_BLUE : TERM_L_RED,
format("Skill points left: %d", p_ptr->skill_points), 2, 0);
print_desc_aux(s_info[table[sel][0]].desc + s_text, 3, 0);
for (j = start; j < start + (hgt - 7); j++)
{
byte color = TERM_WHITE;
char deb = ' ', end = ' ';
if (j >= max) break;
i = table[j][0];
if ((s_info[i].value == 0) && (i != SKILL_MISC))
{
if (s_info[i].mod == 0) color = TERM_L_DARK;
else color = TERM_ORANGE;
}
else if (s_info[i].value == SKILL_MAX) color = TERM_L_BLUE;
if (s_info[i].hidden) color = TERM_L_RED;
if (j == sel)
{
color = TERM_L_GREEN;
deb = '[';
end = ']';
}
if (!has_child(i))
{
c_prt(color, format("%c.%c%s", deb, end, s_info[i].name + s_name),
j + 7 - start, table[j][1] * 4);
}
else if (s_info[i].dev)
{
c_prt(color, format("%c-%c%s", deb, end, s_info[i].name + s_name),
j + 7 - start, table[j][1] * 4);
}
else
{
c_prt(color, format("%c+%c%s", deb, end, s_info[i].name + s_name),
j + 7 - start, table[j][1] * 4);
}
c_prt(color,
format("%s%02ld.%03ld [%01d.%03d]",
s_info[i].value < 0 ? "-" : " ",
ABS(s_info[i].value) / SKILL_STEP,
ABS(s_info[i].value) % SKILL_STEP,
ABS(s_info[i].mod) / 1000,
ABS(s_info[i].mod) % 1000),
j + 7 - start, 60);
}
}
