/* ----------------------------------------------------------------------------
* Handles the events for the area editor.
*/
void area_editor::handle_controls(const ALLEGRO_EVENT &ev) {
if(fade_mgr.is_fading()) return;
gui->handle_event(ev);
//Update mouse cursor in world coordinates.
if(
ev.type == ALLEGRO_EVENT_MOUSE_AXES ||
ev.type == ALLEGRO_EVENT_MOUSE_WARPED ||
ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN ||
ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP
) {
mouse_cursor_x =
ev.mouse.x / cam_zoom - cam_x - (gui_x / 2 / cam_zoom);
mouse_cursor_y =
ev.mouse.y / cam_zoom - cam_y - (scr_h / 2 / cam_zoom);
lafi::widget* wum;
if(!is_mouse_in_gui(ev.mouse.x, ev.mouse.y)) {
wum = NULL;
} else {
wum = gui->get_widget_under_mouse(ev.mouse.x, ev.mouse.y);
}
((lafi::label*) gui->widgets["lbl_status_bar"])->text =
(
wum ?
wum->description :
"(" + i2s(mouse_cursor_x) + "," + i2s(mouse_cursor_y) + ")"
);
}
//Moving vertexes, camera, etc.
if(ev.type == ALLEGRO_EVENT_MOUSE_AXES) {
if(
!is_mouse_in_gui(ev.mouse.x, ev.mouse.y)
&& moving_thing == INVALID && sec_mode != ESM_TEXTURE_VIEW &&
mode != EDITOR_MODE_OBJECTS
) {
on_sector = get_sector(mouse_cursor_x, mouse_cursor_y, NULL, false);
} else {
on_sector = NULL;
}
//Move guide.
if(sec_mode == ESM_GUIDE_MOUSE) {
if(holding_m1) {
guide_x += ev.mouse.dx / cam_zoom;
guide_y += ev.mouse.dy / cam_zoom;
} else if(holding_m2) {
float new_w = guide_w + ev.mouse.dx / cam_zoom;
float new_h = guide_h + ev.mouse.dy / cam_zoom;
if(guide_aspect_ratio) {
//Find the most significant change.
if(ev.mouse.dx != 0 || ev.mouse.dy != 0) {
bool most_is_width =
fabs((double) ev.mouse.dx) >
fabs((double) ev.mouse.dy);
if(most_is_width) {
float ratio = guide_h / guide_w;
guide_w = new_w;
guide_h = new_w * ratio;
} else {
float ratio = guide_w / guide_h;
guide_h = new_h;
guide_w = new_h * ratio;
}
}
} else {
guide_w = new_w;
guide_h = new_h;
}
}
guide_to_gui();
} else if(holding_m2) {
//Move camera.
cam_x += ev.mouse.dx / cam_zoom;
cam_y += ev.mouse.dy / cam_zoom;
}
//Move thing.
if(moving_thing != INVALID) {
if(mode == EDITOR_MODE_SECTORS) {
vertex* v_ptr = cur_area_data.vertexes[moving_thing];
v_ptr->x = snap_to_grid(mouse_cursor_x);
v_ptr->y = snap_to_grid(mouse_cursor_y);
} else if(mode == EDITOR_MODE_OBJECTS) {
mob_gen* m_ptr = cur_area_data.mob_generators[moving_thing];
m_ptr->x = snap_to_grid(mouse_cursor_x);
m_ptr->y = snap_to_grid(mouse_cursor_y);
} else if(mode == EDITOR_MODE_PATHS) {
path_stop* s_ptr = cur_area_data.path_stops[moving_thing];
s_ptr->x = snap_to_grid(mouse_cursor_x);
s_ptr->y = snap_to_grid(mouse_cursor_y);
s_ptr->calculate_dists();
path_preview_timeout.start(false);
} else if(mode == EDITOR_MODE_SHADOWS) {
tree_shadow* s_ptr = cur_area_data.tree_shadows[moving_thing];
s_ptr->x = snap_to_grid(mouse_cursor_x - moving_thing_x);
s_ptr->y = snap_to_grid(mouse_cursor_y - moving_thing_y);
shadow_to_gui();
}
made_changes = true;
}
//Move path checkpoints.
if(moving_path_preview_checkpoint != -1) {
path_preview_checkpoints_x[moving_path_preview_checkpoint] =
snap_to_grid(mouse_cursor_x);
path_preview_checkpoints_y[moving_path_preview_checkpoint] =
snap_to_grid(mouse_cursor_y);
path_preview_timeout.start(false);
}
if(ev.mouse.dz != 0 && !is_mouse_in_gui(ev.mouse.x, ev.mouse.y)) {
//Zoom.
float new_zoom = cam_zoom + (cam_zoom * ev.mouse.dz * 0.1);
new_zoom = max(ZOOM_MIN_LEVEL_EDITOR, new_zoom);
new_zoom = min(ZOOM_MAX_LEVEL_EDITOR, new_zoom);
float new_mc_x =
ev.mouse.x / new_zoom - cam_x - (gui_x / 2 / new_zoom);
float new_mc_y =
ev.mouse.y / new_zoom - cam_y - (scr_h / 2 / new_zoom);
cam_x -= (mouse_cursor_x - new_mc_x);
cam_y -= (mouse_cursor_y - new_mc_y);
mouse_cursor_x = new_mc_x;
mouse_cursor_y = new_mc_y;
cam_zoom = new_zoom;
}
if(sec_mode == ESM_NEW_SECTOR) {
new_sector_valid_line =
is_new_sector_line_valid(
snap_to_grid(mouse_cursor_x),
snap_to_grid(mouse_cursor_y)
);
}
} else if(
ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN &&
!is_mouse_in_gui(ev.mouse.x, ev.mouse.y)
) {
//Clicking.
if(ev.mouse.button == 1) holding_m1 = true;
else if(ev.mouse.button == 2) holding_m2 = true;
else if(ev.mouse.button == 3) cam_zoom = 1.0;
if(ev.mouse.button != 1) return;
//If the user was editing, save it.
if(mode == EDITOR_MODE_SECTORS) {
gui_to_sector();
} else if(mode == EDITOR_MODE_OBJECTS) {
gui_to_mob();
} else if(mode == EDITOR_MODE_SHADOWS) {
gui_to_shadow();
}
//Sector-related clicking.
if(sec_mode == ESM_NONE && mode == EDITOR_MODE_SECTORS) {
moving_thing = INVALID;
edge* clicked_edge_ptr = NULL;
size_t clicked_edge_nr = INVALID;
bool created_vertex = false;
for(size_t e = 0; e < cur_area_data.edges.size(); ++e) {
edge* e_ptr = cur_area_data.edges[e];
if(!is_edge_valid(e_ptr)) continue;
if(
circle_intersects_line(
mouse_cursor_x, mouse_cursor_y, 8 / cam_zoom,
e_ptr->vertexes[0]->x, e_ptr->vertexes[0]->y,
e_ptr->vertexes[1]->x, e_ptr->vertexes[1]->y
)
) {
clicked_edge_ptr = e_ptr;
clicked_edge_nr = e;
break;
}
}
if(double_click_time == 0) double_click_time = 0.5;
else if(clicked_edge_ptr) {
//Create a new vertex.
double_click_time = 0;
//New vertex, on the split point.
//TODO create it on the edge, not on the cursor.
vertex* new_v_ptr = new vertex(mouse_cursor_x, mouse_cursor_y);
cur_area_data.vertexes.push_back(new_v_ptr);
//New edge, copied from the original one.
edge* new_e_ptr = new edge(*clicked_edge_ptr);
cur_area_data.edges.push_back(new_e_ptr);
//Save the original end vertex for later.
vertex* end_v_ptr = clicked_edge_ptr->vertexes[1];
//Set vertexes on the new and original edges.
new_e_ptr->vertex_nrs[0] = cur_area_data.vertexes.size() - 1;
new_e_ptr->vertexes[0] = new_v_ptr;
clicked_edge_ptr->vertex_nrs[1] = new_e_ptr->vertex_nrs[0];
clicked_edge_ptr->vertexes[1] = new_v_ptr;
//Set sectors on the new edge.
if(new_e_ptr->sectors[0]) {
new_e_ptr->sectors[0]->edge_nrs.push_back(
cur_area_data.edges.size() - 1
);
new_e_ptr->sectors[0]->edges.push_back(new_e_ptr);
}
if(new_e_ptr->sectors[1]) {
new_e_ptr->sectors[1]->edge_nrs.push_back(
cur_area_data.edges.size() - 1
);
new_e_ptr->sectors[1]->edges.push_back(new_e_ptr);
}
//Set edges of the new vertex.
new_v_ptr->edge_nrs.push_back(cur_area_data.edges.size() - 1);
new_v_ptr->edge_nrs.push_back(clicked_edge_nr);
new_v_ptr->edges.push_back(new_e_ptr);
new_v_ptr->edges.push_back(clicked_edge_ptr);
//Update edge data on the end vertex of the original edge
//(it now links to the new edge, not the old).
for(size_t ve = 0; ve < end_v_ptr->edges.size(); ++ve) {
if(end_v_ptr->edges[ve] == clicked_edge_ptr) {
end_v_ptr->edges[ve] =
new_e_ptr;
end_v_ptr->edge_nrs[ve] =
cur_area_data.edges.size() - 1;
break;
}
}
//Start dragging the new vertex.
moving_thing = cur_area_data.vertexes.size() - 1;
created_vertex = true;
made_changes = true;
}
//Find a vertex to drag.
if(!created_vertex) {
for(size_t v = 0; v < cur_area_data.vertexes.size(); ++v) {
if(
dist(
mouse_cursor_x, mouse_cursor_y,
cur_area_data.vertexes[v]->x,
cur_area_data.vertexes[v]->y
) <= 6.0 / cam_zoom
) {
moving_thing = v;
break;
}
}
}
//Find a sector to select.
if(moving_thing == INVALID) {
cur_sector =
get_sector(mouse_cursor_x, mouse_cursor_y, NULL, false);
sector_to_gui();
}
} else if(sec_mode == ESM_NONE && mode == EDITOR_MODE_OBJECTS) {
//Object-related clicking.
cur_mob = NULL;
moving_thing = INVALID;
for(size_t m = 0; m < cur_area_data.mob_generators.size(); ++m) {
mob_gen* m_ptr = cur_area_data.mob_generators[m];
float radius =
m_ptr->type ? m_ptr->type->radius == 0 ? 16 :
m_ptr->type->radius : 16;
if(
dist(m_ptr->x, m_ptr->y, mouse_cursor_x, mouse_cursor_y) <=
radius
) {
cur_mob = m_ptr;
moving_thing = m;
break;
}
}
mob_to_gui();
} else if(sec_mode == ESM_NONE && mode == EDITOR_MODE_PATHS) {
//Path-related clicking.
cur_stop = NULL;
moving_thing = INVALID;
for(size_t s = 0; s < cur_area_data.path_stops.size(); ++s) {
path_stop* s_ptr = cur_area_data.path_stops[s];
if(
dist(s_ptr->x, s_ptr->y, mouse_cursor_x, mouse_cursor_y)
<= STOP_RADIUS
) {
cur_stop = s_ptr;
moving_thing = s;
break;
}
}
moving_path_preview_checkpoint = -1;
if(show_path_preview) {
for(unsigned char c = 0; c < 2; ++c) {
if(
bbox_check(
path_preview_checkpoints_x[c],
path_preview_checkpoints_y[c],
mouse_cursor_x, mouse_cursor_y,
PATH_PREVIEW_CHECKPOINT_RADIUS / cam_zoom
)
) {
moving_path_preview_checkpoint = c;
break;
}
}
}
} else if(sec_mode == ESM_NONE && mode == EDITOR_MODE_SHADOWS) {
//Shadow-related clicking.
cur_shadow = NULL;
moving_thing = INVALID;
for(size_t s = 0; s < cur_area_data.tree_shadows.size(); ++s) {
tree_shadow* s_ptr = cur_area_data.tree_shadows[s];
float min_x, min_y, max_x, max_y;
get_shadow_bounding_box(s_ptr, &min_x, &min_y, &max_x, &max_y);
if(
mouse_cursor_x >= min_x && mouse_cursor_x <= max_x &&
mouse_cursor_y >= min_y && mouse_cursor_y <= max_y
) {
cur_shadow = s_ptr;
moving_thing = s;
moving_thing_x = mouse_cursor_x - s_ptr->x;
moving_thing_y = mouse_cursor_y - s_ptr->y;
break;
}
}
shadow_to_gui();
}
if(sec_mode == ESM_NEW_SECTOR) {
//Next vertex in a new sector.
float hotspot_x = snap_to_grid(mouse_cursor_x);
float hotspot_y = snap_to_grid(mouse_cursor_y);
new_sector_valid_line =
is_new_sector_line_valid(
snap_to_grid(mouse_cursor_x),
snap_to_grid(mouse_cursor_y)
);
if(new_sector_valid_line) {
if(
!new_sector_vertexes.empty() &&
dist(
hotspot_x, hotspot_y,
new_sector_vertexes[0]->x,
new_sector_vertexes[0]->y
) <= VERTEX_MERGE_RADIUS
) {
//Back to the first vertex.
sec_mode = ESM_NONE;
create_sector();
sector_to_gui();
made_changes = true;
} else {
//Add a new vertex.
vertex* merge =
get_merge_vertex(
hotspot_x, hotspot_y,
cur_area_data.vertexes,
VERTEX_MERGE_RADIUS / cam_zoom
);
if(merge) {
new_sector_vertexes.push_back(
new vertex(merge->x, merge->y)
);
} else {
new_sector_vertexes.push_back(
new vertex(hotspot_x, hotspot_y)
);
}
}
}
} else if(sec_mode == ESM_NEW_OBJECT) {
//Create a mob where the cursor is.
sec_mode = ESM_NONE;
float hotspot_x = snap_to_grid(mouse_cursor_x);
float hotspot_y = snap_to_grid(mouse_cursor_y);
cur_area_data.mob_generators.push_back(
new mob_gen(hotspot_x, hotspot_y)
);
cur_mob = cur_area_data.mob_generators.back();
mob_to_gui();
made_changes = true;
} else if(sec_mode == ESM_DUPLICATE_OBJECT) {
//Duplicate the current mob to where the cursor is.
sec_mode = ESM_NONE;
if(cur_mob) {
float hotspot_x = snap_to_grid(mouse_cursor_x);
float hotspot_y = snap_to_grid(mouse_cursor_y);
mob_gen* new_mg = new mob_gen(*cur_mob);
new_mg->x = hotspot_x;
new_mg->y = hotspot_y;
cur_area_data.mob_generators.push_back(
new_mg
);
cur_mob = new_mg;
mob_to_gui();
made_changes = true;
}
} else if(sec_mode == ESM_NEW_STOP) {
//Create a new stop where the cursor is.
float hotspot_x = snap_to_grid(mouse_cursor_x);
float hotspot_y = snap_to_grid(mouse_cursor_y);
cur_area_data.path_stops.push_back(
new path_stop(hotspot_x, hotspot_y, vector<path_link>())
);
cur_stop = cur_area_data.path_stops.back();
made_changes = true;
} else if (sec_mode == ESM_NEW_LINK1 || sec_mode == ESM_NEW_1WLINK1) {
//Pick a stop to start the link on.
for(size_t s = 0; s < cur_area_data.path_stops.size(); ++s) {
path_stop* s_ptr = cur_area_data.path_stops[s];
if(
dist(mouse_cursor_x, mouse_cursor_y, s_ptr->x, s_ptr->y) <=
STOP_RADIUS
) {
new_link_first_stop = s_ptr;
sec_mode =
sec_mode == ESM_NEW_LINK1 ? ESM_NEW_LINK2 :
ESM_NEW_1WLINK2;
break;
}
}
path_preview_timeout.start(false);
made_changes = true;
} else if (sec_mode == ESM_NEW_LINK2 || sec_mode == ESM_NEW_1WLINK2) {
//Pick a stop to end the link on.
for(size_t s = 0; s < cur_area_data.path_stops.size(); ++s) {
path_stop* s_ptr = cur_area_data.path_stops[s];
if(
dist(mouse_cursor_x, mouse_cursor_y, s_ptr->x, s_ptr->y) <=
STOP_RADIUS
) {
if(new_link_first_stop == s_ptr) continue;
//Check if these two stops already have a link.
//Delete it if so.
for(
size_t l = 0; l < new_link_first_stop->links.size();
++l
) {
if(new_link_first_stop->links[l].end_ptr == s_ptr) {
new_link_first_stop->links.erase(
new_link_first_stop->links.begin() + l
);
break;
}
}
for(size_t l = 0; l < s_ptr->links.size(); ++l) {
if(s_ptr->links[l].end_ptr == new_link_first_stop) {
s_ptr->links.erase(s_ptr->links.begin() + l);
break;
}
}
new_link_first_stop->links.push_back(
path_link(s_ptr, s)
);
if(sec_mode == ESM_NEW_LINK2) {
s_ptr->links.push_back(
path_link(new_link_first_stop, INVALID)
);
s_ptr->fix_nrs(cur_area_data);
}
new_link_first_stop->calculate_dists();
sec_mode =
sec_mode == ESM_NEW_LINK2 ? ESM_NEW_LINK1 :
ESM_NEW_1WLINK1;
break;
}
}
path_preview_timeout.start(false);
made_changes = true;
} else if(sec_mode == ESM_DEL_STOP) {
//Pick a stop to delete.
for(size_t s = 0; s < cur_area_data.path_stops.size(); ++s) {
path_stop* s_ptr = cur_area_data.path_stops[s];
if(
dist(mouse_cursor_x, mouse_cursor_y, s_ptr->x, s_ptr->y) <=
STOP_RADIUS
) {
//Check all links to this stop.
for(
size_t s2 = 0; s2 < cur_area_data.path_stops.size();
++s2
) {
path_stop* s2_ptr = cur_area_data.path_stops[s2];
for(size_t l = 0; l < s2_ptr->links.size(); ++l) {
if(s2_ptr->links[l].end_ptr == s_ptr) {
s2_ptr->links.erase(s2_ptr->links.begin() + l);
break;
}
}
}
//Finally, delete the stop.
delete s_ptr;
cur_area_data.path_stops.erase(
cur_area_data.path_stops.begin() + s
);
break;
}
}
for(size_t s = 0; s < cur_area_data.path_stops.size(); ++s) {
cur_area_data.path_stops[s]->fix_nrs(cur_area_data);
}
path_preview.clear();
path_preview_timeout.start(false);
made_changes = true;
} else if(sec_mode == ESM_DEL_LINK) {
//Pick a link to delete.
bool deleted = false;
for(size_t s = 0; s < cur_area_data.path_stops.size(); ++s) {
path_stop* s_ptr = cur_area_data.path_stops[s];
for(size_t s2 = 0; s2 < s_ptr->links.size(); ++s2) {
path_stop* s2_ptr = s_ptr->links[s2].end_ptr;
if(
circle_intersects_line(
mouse_cursor_x, mouse_cursor_y, 8 / cam_zoom,
s_ptr->x, s_ptr->y,
s2_ptr->x, s2_ptr->y
)
) {
s_ptr->links.erase(s_ptr->links.begin() + s2);
for(size_t s3 = 0; s3 < s2_ptr->links.size(); ++s3) {
if(s2_ptr->links[s3].end_ptr == s_ptr) {
s2_ptr->links.erase(
s2_ptr->links.begin() + s3
);
break;
}
}
deleted = true;
break;
}
}
if(deleted) break;
}
path_preview.clear();
path_preview_timeout.start(false);
made_changes = true;
} else if(sec_mode == ESM_NEW_SHADOW) {
//Create a new shadow where the cursor is.
sec_mode = ESM_NONE;
float hotspot_x = snap_to_grid(mouse_cursor_x);
float hotspot_y = snap_to_grid(mouse_cursor_y);
tree_shadow* new_shadow = new tree_shadow(hotspot_x, hotspot_y);
new_shadow->bitmap = bmp_error;
cur_area_data.tree_shadows.push_back(new_shadow);
cur_shadow = new_shadow;
shadow_to_gui();
made_changes = true;
}
} else if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_UP) {
//Mouse button release.
if(ev.mouse.button == 1) holding_m1 = false;
else if(ev.mouse.button == 2) holding_m2 = false;
if(
ev.mouse.button == 1 &&
mode == EDITOR_MODE_SECTORS && sec_mode == ESM_NONE &&
moving_thing != INVALID
) {
//Release the vertex.
vertex* moved_v_ptr = cur_area_data.vertexes[moving_thing];
vertex* final_vertex = moved_v_ptr;
unordered_set<sector*> affected_sectors;
//Check if we should merge.
for(size_t v = 0; v < cur_area_data.vertexes.size(); ++v) {
vertex* dest_v_ptr = cur_area_data.vertexes[v];
if(dest_v_ptr == moved_v_ptr) continue;
if(
dist(
moved_v_ptr->x, moved_v_ptr->y,
dest_v_ptr->x, dest_v_ptr->y
) <= (VERTEX_MERGE_RADIUS / cam_zoom)
) {
merge_vertex(
moved_v_ptr, dest_v_ptr, &affected_sectors
);
final_vertex = dest_v_ptr;
break;
}
}
//Finally, re-triangulate the affected sectors.
for(size_t e = 0; e < final_vertex->edges.size(); ++e) {
edge* e_ptr = final_vertex->edges[e];
for(size_t s = 0; s < 2; ++s) {
if(e_ptr->sectors[s]) {
affected_sectors.insert(e_ptr->sectors[s]);
}
}
}
for(
auto s = affected_sectors.begin();
s != affected_sectors.end(); ++s
) {
if(!(*s)) continue;
triangulate(*s);
}
//If somewhere along the line, the current sector
//got marked for deletion, unselect it.
if(cur_sector) {
if(cur_sector->edges.empty()) {
cur_sector = NULL;
sector_to_gui();
}
}
//Check if the edge's vertexes intersect with any other edges.
//If so, they're marked with red.
check_edge_intersections(moved_v_ptr);
moving_thing = INVALID;
} else if(
ev.mouse.button == 1 && sec_mode == ESM_NONE &&
moving_thing != INVALID
) {
//Release thing.
moving_thing = INVALID;
}
moving_path_preview_checkpoint = -1;
} else if(ev.type == ALLEGRO_EVENT_KEY_DOWN) {
//Key press.
if(
ev.keyboard.keycode == ALLEGRO_KEY_LSHIFT ||
ev.keyboard.keycode == ALLEGRO_KEY_RSHIFT
) {
shift_pressed = true;
} else if(ev.keyboard.keycode == ALLEGRO_KEY_F1) {
debug_edge_nrs = !debug_edge_nrs;
} else if(ev.keyboard.keycode == ALLEGRO_KEY_F2) {
debug_sector_nrs = !debug_sector_nrs;
} else if(ev.keyboard.keycode == ALLEGRO_KEY_F3) {
debug_vertex_nrs = !debug_vertex_nrs;
} else if(ev.keyboard.keycode == ALLEGRO_KEY_F4) {
debug_triangulation = !debug_triangulation;
}
} else if(ev.type == ALLEGRO_EVENT_KEY_UP) {
//Key release.
if(
ev.keyboard.keycode == ALLEGRO_KEY_LSHIFT ||
ev.keyboard.keycode == ALLEGRO_KEY_RSHIFT
) {
shift_pressed = false;
}
}
}
BOOST_AUTO_TEST_CASE_TEMPLATE( intint_bgl_mutable_graph_test, Graph, intint_graphtest_types )
{
typedef typename boost::graph_traits<Graph>::vertex_descriptor Vertex;
typedef typename boost::graph_traits<Graph>::vertex_iterator VertexIter;
typedef typename boost::graph_traits<Graph>::edge_descriptor Edge;
typedef typename boost::graph_traits<Graph>::edge_iterator EdgeIter;
typedef typename boost::graph_traits<Graph>::out_edge_iterator OutEdgeIter;
typedef typename boost::graph_traits<Graph>::in_edge_iterator InEdgeIter;
Graph g;
Vertex v_root = Vertex();
BOOST_CHECK_NO_THROW( v_root = add_vertex(g) );
BOOST_CHECK_EQUAL( num_vertices(g), 1);
BOOST_CHECK_NO_THROW( remove_vertex(v_root,g) );
BOOST_CHECK_EQUAL( num_vertices(g), 0);
BOOST_CHECK_NO_THROW( v_root = add_vertex(1, g) );
g[v_root] = 1;
BOOST_CHECK_EQUAL( g[v_root], 1 );
int vp_rc[] = {2,3,4,5};
int ep_rc[] = {1002,1003,1004,1005};
Vertex v_rc[4];
Edge e_rc[4];
for(int i = 0; i < 4; ++i) {
BOOST_CHECK_NO_THROW( v_rc[i] = add_vertex(g) );
g[ v_rc[i] ] = vp_rc[i];
BOOST_CHECK_EQUAL( g[ v_rc[i] ], vp_rc[i] );
bool edge_added_success = false;
BOOST_CHECK_NO_THROW( boost::tie(e_rc[i],edge_added_success) = add_edge(v_root, v_rc[i], g) );
BOOST_CHECK( edge_added_success );
g[ e_rc[i] ] = ep_rc[i];
BOOST_CHECK_EQUAL( g[ e_rc[i] ], ep_rc[i] );
};
BOOST_CHECK_EQUAL( num_vertices(g), 5 );
int vp_rc1c[] = {6,7,8,9};
int ep_rc1c[] = {2006,2007,2008,2009};
Vertex v_rc1c[4];
Edge e_rc1c[4];
for(std::size_t i = 0; i < 4; ++i) {
BOOST_CHECK_NO_THROW( v_rc1c[i] = add_vertex(vp_rc1c[i], g) );
BOOST_CHECK_EQUAL( g[ v_rc1c[i] ], vp_rc1c[i] );
bool edge_added_success = false;
BOOST_CHECK_NO_THROW( boost::tie(e_rc1c[i],edge_added_success) = add_edge(v_rc[0], v_rc1c[i], ep_rc1c[i], g) );
BOOST_CHECK( edge_added_success );
BOOST_CHECK_EQUAL( g[ e_rc1c[i] ], ep_rc1c[i] );
};
BOOST_CHECK_EQUAL( num_vertices(g), 9 );
BOOST_CHECK_EQUAL( g[v_root], 1 );
{
OutEdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei,ei_end) = out_edges(v_root,g) );
std::vector<int> e_list;
for(; ei != ei_end; ++ei) {
if(is_edge_valid(*ei,g)) {
BOOST_CHECK_EQUAL( g[*ei], (g[source(*ei,g)] * 1000 + g[target(*ei,g)]) );
e_list.push_back(g[*ei]);
};
};
std::sort(e_list.begin(), e_list.end());
BOOST_CHECK_EQUAL( e_list[0], 1002);
BOOST_CHECK_EQUAL( e_list[1], 1003);
BOOST_CHECK_EQUAL( e_list[2], 1004);
BOOST_CHECK_EQUAL( e_list[3], 1005);
InEdgeIter iei, iei_end;
BOOST_CHECK_NO_THROW( boost::tie(iei, iei_end) = in_edges(v_rc[0], g) );
BOOST_CHECK( iei != iei_end );
BOOST_CHECK_EQUAL( g[*iei], 1002);
++iei;
BOOST_CHECK( iei == iei_end );
BOOST_CHECK_NO_THROW( boost::tie(ei,ei_end) = out_edges(v_rc[0],g) );
std::vector<int> e_list2;
for(; ei != ei_end; ++ei) {
if(is_edge_valid(*ei,g)) {
BOOST_CHECK_EQUAL( g[*ei], (g[source(*ei,g)] * 1000 + g[target(*ei,g)]) );
e_list2.push_back(g[*ei]);
};
};
std::sort(e_list2.begin(), e_list2.end());
BOOST_CHECK_EQUAL( e_list2[0], 2006);
BOOST_CHECK_EQUAL( e_list2[1], 2007);
BOOST_CHECK_EQUAL( e_list2[2], 2008);
BOOST_CHECK_EQUAL( e_list2[3], 2009);
};
int vp_rc2c[] = {10,11,12,13};
int ep_rc2c[] = {3010,3011,3012,3013};
Vertex v_rc2c[4];
Edge e_rc2c[4];
for(std::size_t i = 0; i < 4; ++i) {
#ifdef RK_ENABLE_CXX0X_FEATURES
BOOST_CHECK_NO_THROW( v_rc2c[i] = add_vertex(std::move(vp_rc2c[i]), g) );
#else
BOOST_CHECK_NO_THROW( v_rc2c[i] = add_vertex(vp_rc2c[i], g) );
#endif
bool edge_added_success = false;
#ifdef RK_ENABLE_CXX0X_FEATURES
BOOST_CHECK_NO_THROW( boost::tie(e_rc2c[i],edge_added_success) = add_edge(v_rc[1], v_rc2c[i], ep_rc2c[i], g) );
#else
BOOST_CHECK_NO_THROW( boost::tie(e_rc2c[i],edge_added_success) = add_edge(v_rc[1], v_rc2c[i], ep_rc2c[i], g) );
#endif
BOOST_CHECK( edge_added_success );
};
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
OutEdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei,ei_end) = out_edges(v_rc[1],g) );
std::vector<int> e_list;
std::vector<int> vp_list;
for(; ei != ei_end; ++ei) {
if(is_edge_valid(*ei,g)) {
BOOST_CHECK_EQUAL( g[*ei], (g[source(*ei,g)] * 1000 + g[target(*ei,g)]) );
e_list.push_back(g[*ei]);
vp_list.push_back(g[target(*ei,g)]);
};
};
std::sort(e_list.begin(), e_list.end());
BOOST_CHECK_EQUAL( e_list[0], 3010);
BOOST_CHECK_EQUAL( e_list[1], 3011);
BOOST_CHECK_EQUAL( e_list[2], 3012);
BOOST_CHECK_EQUAL( e_list[3], 3013);
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 10);
BOOST_CHECK_EQUAL( vp_list[1], 11);
BOOST_CHECK_EQUAL( vp_list[2], 12);
BOOST_CHECK_EQUAL( vp_list[3], 13);
};
BOOST_CHECK_NO_THROW( clear_vertex(v_rc[0],g) );
BOOST_CHECK_EQUAL( out_degree(v_rc[0], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc[0], g), 0 );
BOOST_CHECK_EQUAL( out_degree(v_root, g), 3 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[0], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[1], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[2], g), 0 );
BOOST_CHECK_EQUAL( in_degree(v_rc1c[3], g), 0 );
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi)
if( is_vertex_valid(*vi, g) )
vp_list.push_back( g[*vi] );
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 10 );
BOOST_CHECK_EQUAL( vp_list[10], 11 );
BOOST_CHECK_EQUAL( vp_list[11], 12 );
BOOST_CHECK_EQUAL( vp_list[12], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 7 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei)
if( is_edge_valid(*ei, g) )
ep_list.push_back( g[*ei] );
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3010 );
BOOST_CHECK_EQUAL( ep_list[4], 3011 );
BOOST_CHECK_EQUAL( ep_list[5], 3012 );
BOOST_CHECK_EQUAL( ep_list[6], 3013 );
};
BOOST_CHECK_NO_THROW( remove_edge(v_rc[1], v_rc2c[2], g) );
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi) {
if( is_vertex_valid(*vi, g) ) {
vp_list.push_back( g[*vi] );
};
};
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 10 );
BOOST_CHECK_EQUAL( vp_list[10], 11 );
BOOST_CHECK_EQUAL( vp_list[11], 12 );
BOOST_CHECK_EQUAL( vp_list[12], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 6 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei) {
if( is_edge_valid(*ei, g) ) {
ep_list.push_back( g[*ei] );
};
};
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3010 );
BOOST_CHECK_EQUAL( ep_list[4], 3011 );
BOOST_CHECK_EQUAL( ep_list[5], 3013 );
};
BOOST_CHECK_NO_THROW( remove_edge(e_rc2c[3], g) );
BOOST_CHECK_EQUAL( num_vertices(g), 13 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi) {
if( is_vertex_valid(*vi, g) ) {
vp_list.push_back( g[*vi] );
};
};
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 10 );
BOOST_CHECK_EQUAL( vp_list[10], 11 );
BOOST_CHECK_EQUAL( vp_list[11], 12 );
BOOST_CHECK_EQUAL( vp_list[12], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 5 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei) {
if( is_edge_valid(*ei, g) ) {
ep_list.push_back( g[*ei] );
};
};
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3010 );
BOOST_CHECK_EQUAL( ep_list[4], 3011 );
};
BOOST_CHECK_NO_THROW( clear_vertex(v_rc2c[0], g) );
BOOST_CHECK_NO_THROW( remove_vertex(v_rc2c[0], g) );
BOOST_CHECK_EQUAL( num_vertices(g), 12 );
{
VertexIter vi, vi_end;
BOOST_CHECK_NO_THROW( boost::tie(vi, vi_end) = vertices(g) );
std::vector<int> vp_list;
for(; vi != vi_end; ++vi) {
if( is_vertex_valid(*vi, g) ) {
vp_list.push_back( g[*vi] );
};
};
std::sort(vp_list.begin(), vp_list.end());
BOOST_CHECK_EQUAL( vp_list[0], 1 );
BOOST_CHECK_EQUAL( vp_list[1], 2 );
BOOST_CHECK_EQUAL( vp_list[2], 3 );
BOOST_CHECK_EQUAL( vp_list[3], 4 );
BOOST_CHECK_EQUAL( vp_list[4], 5 );
BOOST_CHECK_EQUAL( vp_list[5], 6 );
BOOST_CHECK_EQUAL( vp_list[6], 7 );
BOOST_CHECK_EQUAL( vp_list[7], 8 );
BOOST_CHECK_EQUAL( vp_list[8], 9 );
BOOST_CHECK_EQUAL( vp_list[9], 11 );
BOOST_CHECK_EQUAL( vp_list[10], 12 );
BOOST_CHECK_EQUAL( vp_list[11], 13 );
};
BOOST_CHECK_EQUAL( num_edges(g), 4 );
{
EdgeIter ei, ei_end;
BOOST_CHECK_NO_THROW( boost::tie(ei, ei_end) = edges(g) );
std::vector<int> ep_list;
for(; ei != ei_end; ++ei) {
if( is_edge_valid(*ei, g) ) {
ep_list.push_back( g[*ei] );
};
};
std::sort(ep_list.begin(), ep_list.end());
BOOST_CHECK_EQUAL( ep_list[0], 1003 );
BOOST_CHECK_EQUAL( ep_list[1], 1004 );
BOOST_CHECK_EQUAL( ep_list[2], 1005 );
BOOST_CHECK_EQUAL( ep_list[3], 3011 );
};
};
