inventory_selector::inventory_selector( player &u, item_filter filter )
: columns()
, active_column_index( 0 )
, dropping()
, ctxt("INVENTORY")
, w_inv( newwin( TERMY, TERMX, VIEW_OFFSET_Y, VIEW_OFFSET_X ) )
, navigation( navigation_mode::ITEM )
, weapon_cat("WEAPON", _("WEAPON HELD"), 0)
, worn_cat("ITEMS WORN", _("ITEMS WORN"), 0)
, u(u)
{
ctxt.register_action("DOWN", _("Next item"));
ctxt.register_action("UP", _("Previous item"));
ctxt.register_action("RIGHT", _("Confirm"));
ctxt.register_action("LEFT", _("Switch inventory/worn"));
ctxt.register_action("CONFIRM", _("Mark selected item"));
ctxt.register_action("QUIT", _("Cancel"));
ctxt.register_action("CATEGORY_SELECTION");
ctxt.register_action("NEXT_TAB", _("Page down"));
ctxt.register_action("PREV_TAB", _("Page up"));
ctxt.register_action("HOME", _("Home"));
ctxt.register_action("END", _("End"));
ctxt.register_action("HELP_KEYBINDINGS");
ctxt.register_action("ANY_INPUT"); // For invlets
std::unique_ptr<inventory_column> first_column( new inventory_column() );
std::unique_ptr<inventory_column> second_column( new inventory_column() );
first_column->add_entries( u.inv.indexed_slice_filter_by( filter ) );
if( !first_column->empty() ) {
insert_column( columns.end(), first_column );
}
if( u.is_armed() && filter( u.weapon ) ) {
second_column->add_entry( inventory_entry( &u.weapon, -1, &weapon_cat ) );
}
size_t i = 0;
for( const auto &it : u.worn ) {
if( filter( it ) ) {
second_column->add_entry( inventory_entry( &it, player::worn_position_to_index( i ), &worn_cat ) );
}
++i;
}
if( !second_column->empty() ) {
insert_column( columns.end(), second_column );
}
}
inline size_t Descriptor::add_column(DataType type, StringData name, DescriptorRef* subdesc,
bool nullable)
{
size_t col_ndx = m_spec->get_public_column_count();
insert_column(col_ndx, type, name, subdesc, nullable); // Throws
return col_ndx;
}
void inventory_selector::prepare_columns( bool multiselect )
{
for( auto &column : columns ) {
column->set_multiselect( multiselect );
}
if( custom_column != nullptr ) {
if( columns.empty() || column_can_fit( *custom_column ) ) {
// Make the column second if possible
const auto position = ( !columns.empty() ) ? std::next( columns.begin() ) : columns.begin();
custom_column->set_multiselect( multiselect );
insert_column( position, custom_column );
} else {
columns.front()->add_entries( *custom_column );
custom_column.release();
}
}
for( auto &column : columns ) {
column->prepare_paging( getmaxy( w_inv ) - 5 );
}
refresh_active_column();
}
/***********************************************************************//**
* @brief Append column to the table
*
* @param[in] column Column which should be appended to table.
*
* A column will be appended at the end of the table. See
* GFitsTable::insert_column
* for more details on the method.
***************************************************************************/
void GFitsTable::append_column(GFitsTableCol& column)
{
// Inserting at the end correspond to appending
insert_column(m_cols, column);
// Return
return;
}
int html_table::add_column (int coln, int hstart, int hend, char align)
{
cols *c = get_column(coln);
if (c == NULL)
return insert_column(coln, hstart, hend, align);
else
return modify_column(c, hstart, hend, align);
}
void inventory_selector::insert_selection_column( const std::string &id, const std::string &name )
{
std::unique_ptr<inventory_column> new_column( new selection_column( id, name ) );
for( const auto &column : columns ) {
static_cast<selection_column *>( new_column.get() )->reserve_width_for( *column );
}
if( column_can_fit( *new_column ) ) { // Insert only if it will be visible. Ignore otherwise.
insert_column( columns.end(), new_column );
}
}
inventory_selector::inventory_selector( player &u, const std::string &title, const item_location_filter &filter )
: u(u)
, ctxt( "INVENTORY" )
, title( title )
, filter( filter )
, w_inv( newwin( TERMY, TERMX, VIEW_OFFSET_Y, VIEW_OFFSET_X ) )
, columns()
, active_column_index( 0 )
, navigation( navigation_mode::ITEM )
{
ctxt.register_action("DOWN", _("Next item"));
ctxt.register_action("UP", _("Previous item"));
ctxt.register_action("RIGHT", _("Confirm"));
ctxt.register_action("LEFT", _("Switch inventory/worn"));
ctxt.register_action("CONFIRM", _("Mark selected item"));
ctxt.register_action("QUIT", _("Cancel"));
ctxt.register_action("CATEGORY_SELECTION");
ctxt.register_action("NEXT_TAB", _("Page down"));
ctxt.register_action("PREV_TAB", _("Page up"));
ctxt.register_action("HOME", _("Home"));
ctxt.register_action("END", _("End"));
ctxt.register_action("HELP_KEYBINDINGS");
ctxt.register_action("ANY_INPUT"); // For invlets
std::unique_ptr<inventory_column> first_column( new inventory_column() );
std::unique_ptr<inventory_column> second_column( new inventory_column() );
for( size_t i = 0; i < u.inv.size(); ++i ) {
const auto &stack = u.inv.const_stack( i );
const auto location = std::make_shared<item_location>( u, const_cast<item *>( &stack.front() ) );
if( filter( *location ) ) {
first_column->add_entry( inventory_entry( location, stack.size() ) );
}
}
if( !first_column->empty() ) {
insert_column( columns.end(), first_column );
}
if( u.is_armed() ) {
categories.emplace_back( "WEAPON", _( "WEAPON HELD" ), 0 );
const auto location = std::make_shared<item_location>( u, &u.weapon );
if( filter( *location ) ) {
second_column->add_entry( inventory_entry( location, &categories.back(), c_ltblue ) );
}
}
if( !u.worn.empty() ) {
categories.emplace_back( "ITEMS WORN", _( "ITEMS WORN" ), 0 );
for( auto &it : u.worn ) {
const auto location = std::make_shared<item_location>( u, &it );
if( filter( *location ) ) {
second_column->add_entry( inventory_entry( location, &categories.back(), c_cyan ) );
}
}
}
if( !second_column->empty() ) {
insert_column( columns.end(), second_column );
}
}
void EditorAbsTable::split_single_cell_by_horisontal(int x, int y, int div)
{
// Проверка, можно ли разбивать ячейку
bool splitEnable=false;
if(cells[x][y].get_cell_type()==EditorAbsTableCell::IS_NORMAL_CELL)
splitEnable=true;
else if(cells[x][y].get_html_property("colspan").toInt()==0 ||
cells[x][y].get_html_property("colspan").toInt()==1)
splitEnable=true;
if(splitEnable==false)
criticalError("Cell ("+QString::number(x)+","+QString::number(y)+") can not split by horisontal to "+QString::number(div)+" parts. Method split_single_cell_by_horisontal().");
// Перебирается счетчик разбиений
for(int k=1; k<div; k++) {
clear_supercell_size_is_modify();
// Вставляется новый столбец справа от столбца с координатой X
insert_column(x);
qDebug() << "Internal table after insert column";
print_internal_table();
// Столбцы (основной и только что созданный) пробегаются сверху-вниз
for(int i=0; i<rows; i++) {
// Если обнаружена нулевая ячейка
if(cells[x][i].get_cell_type()==EditorAbsTableCell::IS_NULL_CELL) {
// Значит что-то не так, нулевых ячеек в этом столбце быть не должно
criticalError("Detect null cell while split by horisontal cell "+QString::number(x)+" "+QString::number(i));
}
// Если обрабатывается ячейка выше или ниже разбиваемой
if(i!=y) {
switch( cells[x][i].get_cell_type() ) {
// Если это обычная ячейка
case EditorAbsTableCell::IS_NORMAL_CELL: {
// Она становится суперячейкой, объединяющей две ячейки
cells[x][i].set_cell_type(EditorAbsTableCell::IS_SUPER_CELL);
cells[x][i].set_html_property("colspan","2");
// А соседняя справа становится подчиненной ячейкой
cells[x+1][i].set_cell_type(EditorAbsTableCell::IS_SUB_CELL);
cells[x+1][i].set_ref_super_cell_xy(x,i);
break;
}
// Если это супер ячейка
case EditorAbsTableCell::IS_SUPER_CELL: {
// Расширить суперячейку можно только один раз
if(cells[x][i].get_supercell_size_is_modify()==false) {
// У этой суперячейки увеличивается colspan
// И отмечается, что размер был изменен
int colspan=cells[x][i].get_html_property("colspan").toInt();
if(colspan==0)colspan=1;
colspan++;
cells[x][i].set_html_property("colspan",QString::number(colspan));
cells[x][i].set_supercell_size_is_modify(true);
}
// Соседняя справа становится подчиненной ячейкой
cells[x+1][i].set_cell_type(EditorAbsTableCell::IS_SUB_CELL);
cells[x+1][i].set_ref_super_cell_xy(x,i);
break;
}
// Если это подчиненная ячейка
case EditorAbsTableCell::IS_SUB_CELL: {
// Соседняя справа становится подчиненной ячейкой
cells[x+1][i].set_cell_type(EditorAbsTableCell::IS_SUB_CELL);
// Выясняются координаты суперячейки для текущей
int super_x=cells[x][i].get_ref_super_cell_x();
int super_y=cells[x][i].get_ref_super_cell_y();
// Если координаты указывают не на разбиваемую ячейку
if(!(super_x==x && super_y==y)) {
// Координаты ссылки на суперячейку (у соседней справа ячейки)
// ставятся такие же как у текущей
cells[x+1][i].set_ref_super_cell_xy(super_x,super_y);
// Расширить суперячейку можно только один раз
if(cells[super_x][super_y].get_supercell_size_is_modify()==false) {
// В самой суперячейке увеличивается colspan, так как она
// стала содержать на единицу больше ячеек
int temp_colspan=cells[super_x][super_y].get_html_property("colspan").toInt();
cells[super_x][super_y].set_html_property("colspan",QString::number(temp_colspan+1));
// Отмечается, что размер был изменен
cells[super_x][super_y].set_supercell_size_is_modify(true);
}
} else {
// Иначе координаты указывают на разбиваемую ячейку
// Поэтому координаты ссылки на суперячейку (у соседней с права ячейки)
// ставятся на суперячейку в только что созданном столбце
cells[x+1][i].set_ref_super_cell_xy(super_x+1,super_y);
}
break;
}
} // Закончился выбор (switch) типа ячейки
} else {
// Иначе в данный момент обрабатывается разбиваемая ячейка
// Эта ячейка обязательно должна быть либо обычной
// Либо суперячейкой с rowspan>1 и colspan<2
if(!(cells[x][i].get_cell_type()==EditorAbsTableCell::IS_NORMAL_CELL ||
cells[x][i].get_cell_type()==EditorAbsTableCell::IS_SUPER_CELL)) {
criticalError("Detect splitting target null or sub cell while split by horisontal cell "+QString::number(x)+" "+QString::number(i));
}
// Проверяем суперячейку на colspan<2
if(cells[x][i].get_cell_type()==EditorAbsTableCell::IS_SUPER_CELL) {
int colspan=cells[x][i].get_html_property("colspan").toInt();
if(colspan>=2)
criticalError("Detect splitting target super cell with colspan "+QString::number(colspan)+" while split by horisontal cell "+QString::number(x)+" "+QString::number(i));
}
// Если ячейка обычная
if(cells[x][i].get_cell_type()==EditorAbsTableCell::IS_NORMAL_CELL) {
// Соседняя справа тоже становится обычной
cells[x+1][i].set_cell_type(EditorAbsTableCell::IS_NORMAL_CELL);
}
// Если суперячейка
if(cells[x][i].get_cell_type()==EditorAbsTableCell::IS_SUPER_CELL) {
// Выяснется rowspan (колько ячеек по высоте объединено)
int rowspan=cells[x][i].get_html_property("rowspan").toInt();
// Соседняя справа тоже становится суперячейкой
// и ей устанавливается такой же rowspan
cells[x+1][i].set_cell_type(EditorAbsTableCell::IS_SUPER_CELL);
cells[x+1][i].set_html_property("rowspan",QString::number(rowspan));
}
} // Закрылось условие обработки ячейки выше или ниже разбиваемой
} // Закончился цикл раздвигания таблицы сверху вниз
} // Закончился цикл итераций разбиения ячейки
qDebug() << "Internal table after slit by horisontal";
print_internal_table();
}
