void veta_handleevent(event_t *event){ switch(event->type){ case QUIT: uk_log("Quit"); ui_quit(); break; case RESET: uk_log("Reset"); clear_selection(root_cell); veta_render(); break; case SELECT_CELL: uk_log("select cell %i",event->cell); // debug_print_tree(root); select_cell(root_cell,event->cell); symbol *sym; if(NULL!=(sym=get_selected_symbol(root_cell))){ clear_selection(root_cell); if(ui2_onselect_symbol(sym)) break; sendkey(sym->data,1,0); } refresh(); break; case UNDEFINED: uk_log("got event UNDEFINED\n"); break; default: uk_log("WARNING undefined event type"); break; } }
static void sync_selection_shapes_to_view(GwyCoordsView *view) { CoordsView *priv = view->priv; GwyShapes *shapes = priv->shapes; if (!shapes) { clear_selection(view); return; } guint n = 0, len = gwy_coords_size(priv->coords); const GwyIntRange *ranges = gwy_int_set_ranges(priv->shapes_selection, &n); if (!n) { clear_selection(view); return; } GtkTreeView *treeview = GTK_TREE_VIEW(view); GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview); priv->sync_shapes_to_view = TRUE; select_or_unselect_range(selection, 0, ranges[0].from, FALSE); for (guint i = 0; ; i++) { select_or_unselect_range(selection, ranges[i].from, ranges[i].to, TRUE); if (i == n-1) break; select_or_unselect_range(selection, ranges[i].to, ranges[i+1].from, FALSE); } select_or_unselect_range(selection, ranges[n-1].to, len, FALSE); priv->sync_shapes_to_view = FALSE; }
static void restore_cursor (ETreeSelectionModel *etsm, ETreeModel *etm) { clear_selection (etsm); etsm->priv->cursor_path = NULL; if (etsm->priv->cursor_save_id) { etsm->priv->cursor_path = e_tree_model_get_node_by_id ( etm, etsm->priv->cursor_save_id); if (etsm->priv->cursor_path != NULL && etsm->priv->cursor_col == -1) etsm->priv->cursor_col = 0; select_single_path (etsm, etsm->priv->cursor_path); } e_selection_model_selection_changed (E_SELECTION_MODEL (etsm)); if (etsm->priv->cursor_path) { gint cursor_row = get_cursor_row (etsm); e_selection_model_cursor_changed ( E_SELECTION_MODEL (etsm), cursor_row, etsm->priv->cursor_col); } else { e_selection_model_cursor_changed ( E_SELECTION_MODEL (etsm), -1, -1); e_selection_model_cursor_activated ( E_SELECTION_MODEL (etsm), -1, -1); } free_id (etsm); }
static void tree_selection_model_select_all (ESelectionModel *selection) { ETreeSelectionModel *etsm = E_TREE_SELECTION_MODEL (selection); ETreePath root; root = e_tree_model_get_root (etsm->priv->model); if (root == NULL) return; clear_selection (etsm); /* We want to select ALL rows regardless of expanded state. * ETreeTableAdapter pretends that collapsed rows don't exist, * so instead we need to iterate over the ETreeModel directly. */ e_tree_model_node_traverse ( etsm->priv->model, root, tree_selection_model_traverse_cb, selection); if (etsm->priv->cursor_path == NULL) etsm->priv->cursor_path = e_tree_table_adapter_node_at_row ( etsm->priv->etta, 0); e_selection_model_selection_changed (E_SELECTION_MODEL (etsm)); e_selection_model_cursor_changed ( E_SELECTION_MODEL (etsm), get_cursor_row (etsm), etsm->priv->cursor_col); }
void ViewWidget::mouse_left_press_event(QMouseEvent *event) { (void)event; const bool ctrl_pressed = QApplication::keyboardModifiers() & Qt::ControlModifier; // Clear selection if control is not pressed and this item is unselected if ((!mouse_down_item_ || !mouse_down_item_->selected()) && !ctrl_pressed) clear_selection(); // Set the signal selection state if the item has been clicked if (mouse_down_item_) { if (ctrl_pressed) mouse_down_item_->select(!mouse_down_item_->selected()); else mouse_down_item_->select(true); } // Save the offsets of any signals which will be dragged bool item_dragged = false; const auto items = this->items(); for (auto &i : items) if (i->selected()) { item_dragged = true; i->drag(); } // Do the background drag if (!item_dragged) drag(); selection_changed(); }
/** * @brief Deletes an animation. * * The index of the selection may change, since animations are sorted * alphabetically. * Emits rowsAboutToBeRemoved(), removes the animation * and then emits rowsRemoved(), as required by QAbstractItemModel. * * Then, emits animation_deleted(). * * Except for the deleted animation, the existing selection is preserved, * though the index of many animations can change. * The selection is cleared before the operations and restored after, * updated with the new index. * * @param index Index of the animation to delete. * @throws EditorException in case of error. */ void SpriteModel::delete_animation(const Index &index) { // Make some checks first. if (!animation_exists(index)) { throw EditorException( tr("Animation '%1' don't exists").arg(index.animation_name)); } // Save and clear the selection since a lot of indexes may change. Index selection = get_selected_index(); clear_selection(); int animation_nb = get_animation_nb(index); // Delete the animation in the sprite file. sprite.remove_animation(index.animation_name.toStdString()); // Rebuild indexes in the list model (indexes were shifted). build_index_map(); // Call beginRemoveRows() as requested by QAbstractItemModel. beginRemoveRows(QModelIndex(), animation_nb, animation_nb); // Update our animation model list. animations.removeAt(animation_nb); // Notify people before restoring the selection, so that they have a // chance to know new indexes before receiving selection signals. endRemoveRows(); emit animation_deleted(index); // Restore the selection. set_selected_index(selection); }
bool Mesh::complexify() { if (selection != SELECTION_FACE) return false; float xyz[3] = {0}; for (int v : face_selected.face->getVerts()) for (int i = 0; i < 3; i++) xyz[i] += verts[v].getCoords()[i] / face_selected.face->getVerts().size(); Vertex centroid = Vertex(xyz); centroid.set_deletable(true); addVerts(centroid); for (unsigned int i = 0; i < face_selected.face->getVerts().size(); i++) { Face* f = new Face(); f->addVert(face_selected.face->getVerts()[i]); f->addVert(face_selected.face->getVerts()[(i + 1) % (face_selected.face->getVerts().size())]); f->addVert(verts.size() - 1); groups[face_selected.group_pos]->addFace(f); } groups[face_selected.group_pos]->eraseFaceAt(face_selected.face_pos); clear_selection(); return true; }
/** * @brief Changes the id of a dialog. * * The index of multiple dialogs may change, since they are sorted alphabetically. * In this case, emits rowsAboutToBeRemoved(), removes the dialog, * emits rowsRemoved() and rowsAboutToBeInserted(), adds the new dialog * and then emits rowsInserted(), as required by QAbstractItemModel. * * Then, emits dialog_id_changed(), no matter if the index has also changed. * * The selection is preserved, though the index of many dialogs can change. * The selection is cleared before the operations and restored after, * updated with the new indexes. * * @param id Id of an existing dialog. * @param new_id The new id to set. * @return The new id of the dialog. * @throws EditorException in case of error. */ QString DialogsModel::set_dialog_id(const QString& id, const QString& new_id) { if (new_id == id) { // Nothing to do. return id; } // Make some checks first. if (!dialog_exists(id)) { throw EditorException(tr("Dialog '%1' no exists").arg(id)); } if (dialog_exists(new_id)) { throw EditorException(tr("Dialog '%1' already exists").arg(new_id)); } if (!is_valid_id(new_id)) { throw EditorException(tr("Invalid dialog id: %1").arg(new_id)); } // Save and clear the selection since a lot of indexes may change. QString old_selection = get_selected_id(); clear_selection(); // Change in to the strings file. resources.set_dialog_id(id.toStdString(), new_id.toStdString()); // Remove from the indexed tree. QString parent_id; int index; if (dialog_tree.can_remove_key(id, parent_id, index)) { // Call beginRemoveRows() as requested by QAbstractItemModel. beginRemoveRows(id_to_index(parent_id), index, index); dialog_tree.remove_key(id); endRemoveRows(); } else if (dialog_tree.remove_key(id)) { QModelIndex model_index = id_to_index(id); dataChanged(model_index, model_index); } // Add to the indexed tree. if (dialog_tree.add_key(new_id, parent_id, index)) { // Call beginInsertRows() as requested by QAbstractItemModel. beginInsertRows(id_to_index(parent_id), index, index); endInsertRows(); } else { QModelIndex model_index = id_to_index(id); dataChanged(model_index, model_index); } // Notify people. emit dialog_id_changed(id, new_id); // Restore the selection. set_selected_id(old_selection); return new_id; }
void CL_ListView::clear() { impl->cancel_edit(); clear_selection(); impl->document_item.remove_children(); request_repaint(); }
/** * @brief Selects a dialog and deselects all others. * @param id The id to select. */ void DialogsModel::set_selected_id(const QString& id) { if (!dialog_tree.key_exists(id)) { return clear_selection(); } selection_model.select(id_to_index(id), QItemSelectionModel::ClearAndSelect); }
static void select_single_path (ETreeSelectionModel *etsm, ETreePath path) { clear_selection (etsm); change_one_path (etsm, path, TRUE); etsm->priv->cursor_path = path; etsm->priv->start_path = NULL; }
bool editor_map::set_selection(const std::set<map_location>& area) { clear_selection(); BOOST_FOREACH(const map_location& loc, area) { if (!add_to_selection(loc)) return false; } return true; }
/** * @brief Moves a direction. * @param index Index of the direction to move. * @param new_direction_nb The new number of the direction. * @throws EditorException in case of error. */ void SpriteModel::move_direction(const Index& index, int new_direction_nb) { if (new_direction_nb == index.direction_nb) { // Nothing to do. return; } // Make some checks first. if (!direction_exists(index)) { QString nb = std::to_string(index.direction_nb).c_str(); throw EditorException( tr("Direction %1 don't exists in animation '%2'").arg( nb, index.animation_name)); } // Save and clear the selection. Index selection = get_selected_index(); clear_selection(); // Move the direction in the sprite file. get_animation(index).move_direction(index.direction_nb, new_direction_nb); // Call beginMoveRows() as requested by QAbstractItemModel. int above_row = new_direction_nb; if (new_direction_nb > index.direction_nb) { ++above_row; } QModelIndex model_index = get_model_index(Index(index.animation_name)); beginMoveRows(model_index, index.direction_nb, index.direction_nb, model_index, above_row); // Update our animation model list. int animation_nb = get_animation_nb(index); animations[animation_nb].directions.move(index.direction_nb, new_direction_nb); // Update direction model indexes. int num_dir = animations[animation_nb].directions.size(); for (int nb = 0; nb < num_dir; nb++) { animations[animation_nb].directions[nb].index->direction_nb = nb; } endMoveRows(); // Notify people before restoring the selection, so that they have a // chance to know new indexes before receiving selection signals. emit direction_deleted(index); // Restore the selection. if (selection.direction_nb == index.direction_nb) { selection.direction_nb = new_direction_nb; } set_selected_index(selection); }
static void tree_selection_model_clear (ESelectionModel *selection) { ETreeSelectionModel *etsm = E_TREE_SELECTION_MODEL (selection); clear_selection (etsm); etsm->priv->cursor_path = NULL; e_selection_model_selection_changed (E_SELECTION_MODEL (etsm)); e_selection_model_cursor_changed (E_SELECTION_MODEL (etsm), -1, -1); }
void CSSLayout::set_selection(CSSLayoutNode start, size_t start_text_offset, CSSLayoutNode end, size_t end_text_offset) { impl->throw_if_disposed(); if (start.is_null() || end.is_null()) { clear_selection(); } else { impl->box_tree.set_selection(start.impl->box_node, start_text_offset, end.impl->box_node, end_text_offset); } }
void veta_symbolsloaded(symbol *symbols,int n){ if(n==0) return; symbolsloaded++; uk_log("Symbols are loaded got %i symbols",n); conf_save_symbols("platform_symbols.json",symbols,n); int cellsize=conf_get_int("n_columns",CELLS_W)*conf_get_int("n_rows",CELLS_H); root_cell=create_cells(symbols,n,cellsize,TREE_DEPTH,1); clear_selection(root_cell); }
static void tree_selection_model_finalize (GObject *object) { ETreeSelectionModelPrivate *priv; priv = E_TREE_SELECTION_MODEL_GET_PRIVATE (object); clear_selection (E_TREE_SELECTION_MODEL (object)); g_hash_table_destroy (priv->paths); /* Chain up to parent's finalize() method. */ G_OBJECT_CLASS (e_tree_selection_model_parent_class)->finalize (object); }
void __set_origin(unsigned short offset) { unsigned long flags; clear_selection(); save_flags(flags); cli(); __origin = offset; /* outb_p(12, video_port_reg); */ /* outb_p(offset >> 8, video_port_val); */ /* outb_p(13, video_port_reg); */ /* outb_p(offset, video_port_val); */ restore_flags(flags); }
static void etsm_real_move_selection_end (ETreeSelectionModel *etsm, gint row) { ETreePath end_path; gint start; end_path = e_tree_table_adapter_node_at_row (etsm->priv->etta, row); g_return_if_fail (end_path); start = e_tree_table_adapter_row_of_node ( etsm->priv->etta, etsm->priv->start_path); clear_selection (etsm); select_range (etsm, start, row); }
/** * @brief Inserts a direction in an animation of this sprite. * @param index Index of the direction to insert. * @param data The direction data to insert. * @return Index of the inserted direction. * @throws EditorException in case of error. */ int SpriteModel::insert_direction( const Index& index, const SpriteAnimationDirectionData& data) { // Make some checks first. if (!animation_exists(index)) { throw EditorException( tr("Animation '%1' don't exists").arg(index.animation_name)); } // Save and clear the selection. Index selection = get_selected_index(); clear_selection(); // Insert the direction to the sprite file. SpriteAnimationData& animation_data = get_animation(index); animation_data.add_direction(data); int last_dir = animation_data.get_num_directions() - 1; animation_data.move_direction(last_dir, index.direction_nb); int direction_nb = std::min(index.direction_nb, last_dir); // Call beginInsertRows() as requested by QAbstractItemModel. QModelIndex model_index = get_model_index(Index(index.animation_name)); beginInsertRows(model_index, direction_nb, direction_nb); // Update our animation model list. int animation_nb = get_animation_nb(index); auto& directions = animations[animation_nb].directions; directions.insert( direction_nb, DirectionModel(index.animation_name, direction_nb)); // Update direction model indexes. for (int nb = direction_nb + 1; nb < directions.size(); nb++) { directions[nb].index->direction_nb = nb; } // Notify people before restoring the selection, so that they have a // chance to know new indexes before receiving selection signals. endInsertRows(); emit direction_added(Index(index.animation_name, direction_nb)); // Restore the selection. set_selected_index(selection); return direction_nb; }
/** * @brief Deletes a direction. * @param index Index of the direction to delete. * @throws EditorException in case of error. */ void SpriteModel::delete_direction(const Index &index) { // Make some checks first. if (!direction_exists(index)) { QString nb = std::to_string(index.direction_nb).c_str(); throw EditorException( tr("Direction %1 don't exists in animation '%2'").arg( nb, index.animation_name)); } // Save and clear the selection. Index selection = get_selected_index(); if (selection.animation_name == index.animation_name && selection.direction_nb == index.direction_nb) { selection.direction_nb = -1; } clear_selection(); // Delete the direction in the sprite file. get_animation(index).remove_direction(index.direction_nb); // Call beginRemoveRows() as requested by QAbstractItemModel. QModelIndex model_index = get_model_index(Index(index.animation_name)); beginRemoveRows(model_index, index.direction_nb, index.direction_nb); // Update our direction model list. int animation_nb = get_animation_nb(index); auto& directions = animations[animation_nb].directions; directions.removeAt(index.direction_nb); // Update direction model indexes. for (int nb = index.direction_nb; nb < directions.size(); nb++) { directions[nb].index->direction_nb = nb; } // Notify people before restoring the selection, so that they have a // chance to know new indexes before receiving selection signals. endRemoveRows(); emit direction_deleted(index); // Restore the selection. set_selected_index(selection); }
/** * @brief Inserts an animation in this sprite. * * The index of the selection may change, since animations are sorted * alphabetically. * Emits rowsAboutToBeInserted(), inserts the animation * and then emits rowsInserted(), as required by QAbstractItemModel. * * Then, emits animation_created(). * * The newly created animation is not initially selected. * The existing selection is preserved, though the index of many * animations can change. * The selection is cleared before the operations and restored after, * updated with the new index. * * @param index Index of the animation to insert. * @param data Data of the animation. * @throws EditorException in case of error. */ void SpriteModel::insert_animation( const Index& index, const Solarus::SpriteAnimationData& data) { // Make some checks first. if (index.animation_name.length() <= 0) { throw EditorException(tr("Animation name cannot be empty")); } if (animation_exists(index)) { throw EditorException( tr("Animation '%1' already exists").arg(index.animation_name)); } // Save and clear the selection since a lot of indexes may change. Index selection = get_selected_index(); clear_selection(); // Add the animation to the sprite file. sprite.add_animation(index.animation_name.toStdString(), data); // Rebuild indexes in the list model (indexes were shifted). build_index_map(); // Call beginInsertRows() as requested by QAbstractItemModel. int animation_nb = get_animation_nb(index.animation_name); beginInsertRows(QModelIndex(), animation_nb, animation_nb); // Update our animation model list. animations.insert(animation_nb, AnimationModel(index.animation_name)); int num_directions = data.get_num_directions(); for (int nb = 0; nb < num_directions; nb++) { animations[animation_nb].directions.append( DirectionModel(index.animation_name, nb)); } // Notify people before restoring the selection, so that they have a // chance to know new indexes before receiving selection signals. endInsertRows(); emit animation_created(index); // Restore the selection. set_selected_index(selection); }
/** * @brief Adds a direction in an animation of this sprite. * @param index Index of the animation to add the direction. * @param frame The first frame of the direction to create. * @return Index of the created direction. * @throws EditorException in case of error. */ int SpriteModel::add_direction(const Index& index, const QRect& frame) { // Make some checks first. if (!animation_exists(index)) { throw EditorException( tr("Animation '%1' don't exists").arg(index.animation_name)); } // Save and clear the selection. Index selection = get_selected_index(); clear_selection(); // Add the direction to the sprite file. SpriteAnimationData& animation_data = get_animation(index); SpriteAnimationDirectionData direction( Point::to_solarus_point(frame.topLeft()), Size::to_solarus_size(frame.size())); animation_data.add_direction(direction); // Rebuild indexes in the list model (indexes were shifted). int direction_nb = animation_data.get_num_directions() - 1; // Call beginInsertRows() as requested by QAbstractItemModel. QModelIndex model_index = get_model_index(Index(index.animation_name)); beginInsertRows(model_index, direction_nb, direction_nb); // Update our animation model list. int animation_nb = get_animation_nb(index); animations[animation_nb].directions.append( DirectionModel(index.animation_name, direction_nb)); // Notify people before restoring the selection, so that they have a // chance to know new indexes before receiving selection signals. endInsertRows(); emit direction_added(Index(index.animation_name, direction_nb)); // Restore the selection. set_selected_index(selection); return direction_nb; }
/** * @brief Deletes a dialog. * * The index of multiple dialogs may change, since they are sorted alphabetically. * Emits rowsAboutToBeRemoved(), removes the dialog * and then emits rowsRemoved(), as required by QAbstractItemModel. * * Then, emits dialog_deleted(). * * Except for the deleted dialog, the existing selection is preserved, * though the index of many dialogs can change. * The selection is cleared before the operations and restored after, * updated with the new indexes. * * @param id Id of the dialog to delete. * @throws EditorException in case of error. */ void DialogsModel::delete_dialog(const QString& id) { // Make some checks first. if (!dialog_exists(id)) { throw EditorException(tr("Invalid dialog id: %1").arg(id)); } // Save and clear the selection since a lot of indexes may change. QString old_selection = get_selected_id(); clear_selection(); // Delete from the strings file resources.remove_dialog(id.toStdString()); // Remove from the indexed tree. QString parent_id; int index; if (dialog_tree.can_remove_key(id, parent_id, index)) { // Call beginRemoveRows() as requested by QAbstractItemModel. beginRemoveRows(id_to_index(parent_id), index, index); dialog_tree.remove_key(id); // Notify people before restoring the selection, so that they have a // chance to know new indexes before receiving selection signals. endRemoveRows(); } else if (dialog_tree.remove_key(id)) { QModelIndex model_index = id_to_index(id); dataChanged(model_index, model_index); } // Notify people. emit dialog_deleted(id); // Restore the selection. set_selected_id(old_selection); }
void RealPlayer::SelectThing(SelectTypes Thing){ // makes the player "pick up" a potencial building // player does not pay for building, but it does chech if they have enough // match picture with selected building clear_selection(); if (MiniTurn != 0) return; BuildingTypes Build = SelectToBuild(Thing); TInfo::TroopTypes TType = SelectToTroop(Thing); int Cost = 0; if (Build != NoBuild){ Cost = GetBuildingCost(Build); } else if (TType != TInfo::NoType){ Cost = TInfo::GetTroopCost(TType); } if (Cost > Money) MakeDialogue("Sorry, but you do not have enough money to purchace this", "Not Enough Money"); else{ fullscreen->emph->add_build_choice(Thing,Qt::blue); SelectedThing = Thing; } }
/** * @brief Creates a new dialog. * * The index of the selection may change, since dialog are sorted * alphabetically. * Emits rowsAboutToBeInserted(), adds the new dialog * and then emits rowsInserted(), as required by QAbstractItemModel. * * Then, emits dialog_created(). * * The newly created dialog is not initially selected. * The existing selection is preserved, though the index of many * dialogs can change. * The selection is cleared before the operations and restored after, * updated with the new index. * * @param id Id of the dialog to create. * @param data Data of the dialog to create. * @throws EditorException in case of error. */ void DialogsModel::create_dialog(const QString& id, const DialogData& data) { // Make some checks first. if (!is_valid_id(id)) { throw EditorException(tr("Invalid dialog id: %1").arg(id)); } if (dialog_exists(id)) { throw EditorException(tr("Dialog '%1' already exists").arg(id)); } // Save and clear the selection since a lot of indexes may change. QString old_selection = get_selected_id(); clear_selection(); // Add to the strings file. resources.add_dialog(id.toStdString(), data); // Update the indexed tree. QString parent_id; int index; if (dialog_tree.add_key(id, parent_id, index)) { // Notify people before restoring the selection, so that they have a // chance to know new indexes before receiving selection signals. beginInsertRows(id_to_index(parent_id), index, index); endInsertRows(); } else { QModelIndex model_index = id_to_index(id); dataChanged(model_index, model_index); } // Notify people. emit dialog_created(id); // Restore the selection. set_selected_id(old_selection); }
static void shapes_notify(GwyCoordsView *view, GParamSpec *pspec, GwyShapes *shapes) { CoordsView *priv = view->priv; if (gwy_strequal(pspec->name, "coords")) set_coords(view, gwy_shapes_get_coords(shapes)); else if (gwy_strequal(pspec->name, "editable")) priv->editable = gwy_shapes_get_editable(shapes); else if (gwy_strequal(pspec->name, "selectable")) { GtkTreeView *treeview = GTK_TREE_VIEW(view); GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview); if (gwy_shapes_get_selectable(shapes)) { gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); sync_selection_shapes_to_view(view); } else { clear_selection(view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_NONE); } } }
void Mesh::delete_selected_face() { groups[face_selected.group_pos]->eraseFaceAt(face_selected.face_pos); clear_selection(); }
/* set the current selection. Invoked by ioctl() or by kernel code. */ int set_selection(const struct tiocl_selection *sel, struct tty_struct *tty, int user) { int sel_mode, new_sel_start, new_sel_end, spc; char *bp, *obp; int i, ps, pe; unsigned int currcons = fg_console; poke_blanked_console(); { unsigned short xs, ys, xe, ye; if (user) { if (verify_area(VERIFY_READ, sel, sizeof(*sel))) return -EFAULT; __get_user(xs, &sel->xs); __get_user(ys, &sel->ys); __get_user(xe, &sel->xe); __get_user(ye, &sel->ye); __get_user(sel_mode, &sel->sel_mode); } else { xs = sel->xs; /* set selection from kernel */ ys = sel->ys; xe = sel->xe; ye = sel->ye; sel_mode = sel->sel_mode; } xs--; ys--; xe--; ye--; xs = limit(xs, video_num_columns - 1); ys = limit(ys, video_num_lines - 1); xe = limit(xe, video_num_columns - 1); ye = limit(ye, video_num_lines - 1); ps = ys * video_size_row + (xs << 1); pe = ye * video_size_row + (xe << 1); if (sel_mode == TIOCL_SELCLEAR) { /* useful for screendump without selection highlights */ clear_selection(); return 0; } if (mouse_reporting() && (sel_mode & TIOCL_SELMOUSEREPORT)) { mouse_report(tty, sel_mode & TIOCL_SELBUTTONMASK, xs, ys); return 0; } } if (ps > pe) /* make sel_start <= sel_end */ { int tmp = ps; ps = pe; pe = tmp; } if (sel_cons != fg_console) { clear_selection(); sel_cons = fg_console; } switch (sel_mode) { case TIOCL_SELCHAR: /* character-by-character selection */ new_sel_start = ps; new_sel_end = pe; break; case TIOCL_SELWORD: /* word-by-word selection */ spc = isspace(sel_pos(ps)); for (new_sel_start = ps; ; ps -= 2) { if ((spc && !isspace(sel_pos(ps))) || (!spc && !inword(sel_pos(ps)))) break; new_sel_start = ps; if (!(ps % video_size_row)) break; } spc = isspace(sel_pos(pe)); for (new_sel_end = pe; ; pe += 2) { if ((spc && !isspace(sel_pos(pe))) || (!spc && !inword(sel_pos(pe)))) break; new_sel_end = pe; if (!((pe + 2) % video_size_row)) break; } break; case TIOCL_SELLINE: /* line-by-line selection */ new_sel_start = ps - ps % video_size_row; new_sel_end = pe + video_size_row - pe % video_size_row - 2; break; case TIOCL_SELPOINTER: highlight_pointer(pe); return 0; default: return -EINVAL; } /* remove the pointer */ highlight_pointer(-1); /* select to end of line if on trailing space */ if (new_sel_end > new_sel_start && !atedge(new_sel_end, video_size_row) && isspace(sel_pos(new_sel_end))) { for (pe = new_sel_end + 2; ; pe += 2) if (!isspace(sel_pos(pe)) || atedge(pe, video_size_row)) break; if (isspace(sel_pos(pe))) new_sel_end = pe; } if (sel_start == -1) /* no current selection */ highlight(new_sel_start, new_sel_end); else if (new_sel_start == sel_start) { if (new_sel_end == sel_end) /* no action required */ return 0; else if (new_sel_end > sel_end) /* extend to right */ highlight(sel_end + 2, new_sel_end); else /* contract from right */ highlight(new_sel_end + 2, sel_end); } else if (new_sel_end == sel_end) { if (new_sel_start < sel_start) /* extend to left */ highlight(new_sel_start, sel_start - 2); else /* contract from left */ highlight(sel_start, new_sel_start - 2); } else /* some other case; start selection from scratch */ { clear_selection(); highlight(new_sel_start, new_sel_end); } sel_start = new_sel_start; sel_end = new_sel_end; /* Allocate a new buffer before freeing the old one ... */ bp = kmalloc((sel_end-sel_start)/2+1, GFP_KERNEL); if (!bp) { printk(KERN_WARNING "selection: kmalloc() failed\n"); clear_selection(); return -ENOMEM; } if (sel_buffer) kfree(sel_buffer); sel_buffer = bp; obp = bp; for (i = sel_start; i <= sel_end; i += 2) { *bp = sel_pos(i); if (!isspace(*bp++)) obp = bp; if (! ((i + 2) % video_size_row)) { /* strip trailing blanks from line and add newline, unless non-space at end of line. */ if (obp != bp) { bp = obp; *bp++ = '\r'; } obp = bp; } } sel_buffer_lth = bp - sel_buffer; return 0; }
void editor_map::select_all() { clear_selection(); invert_selection(); }