Checks if is editable.

@param row    the row
@param column the column
@return true, if is editable
177200
public boolean isEditable(final int row, final int column) {
		if (isEditable(column)) {
			final int actualIndex = getTableColumn(column).getIndex();
			final JKTableRecord record = getRecord(row);
			return record.isColumnEnabled(actualIndex);
		}
		return false;
	}
682685
private function tryWordInColumn($word, $col, $row)
    {
        $wordArray = Utils::stringToArray($word);

        foreach ($wordArray as $letter) {
            if ($this->grid[$row][$col] !== null &&
                $this->grid[$row][$col] !== $letter
            ) {
                return false;
            }
            $row++;
        }

        return true;
    }
1334585
public void doesNotContainCell(
      @NullableDecl Object rowKey, @NullableDecl Object colKey, @NullableDecl Object value) {
    doesNotContainCell(Tables.<Object, Object, Object>immutableCell(rowKey, colKey, value));
  }
412348
protected boolean isEditable(CmsObject cms) {

        boolean result = false;
        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(m_editableBy)) {
            String[] principals = m_editableBy.split(",");
            List<CmsGroup> groups = null;
            for (int i = 0; i < principals.length; i++) {
                String key = principals[i];
                // get the principal name from the principal String
                String principal = key.substring(key.indexOf('.') + 1, key.length());

                if (CmsGroup.hasPrefix(key)) {
                    // read the group
                    principal = OpenCms.getImportExportManager().translateGroup(principal);
                    try {
                        CmsGroup group = cms.readGroup(principal);
                        if (groups == null) {
                            try {
                                groups = cms.getGroupsOfUser(cms.getRequestContext().getCurrentUser().getName(), false);
                            } catch (Exception ex) {
                                if (LOG.isErrorEnabled()) {
                                    LOG.error(ex.getLocalizedMessage(), ex);
                                }
                                groups = Collections.emptyList();
                            }
                        }
                        result = groups.contains(group);
                    } catch (CmsException e) {
                        if (LOG.isErrorEnabled()) {
                            LOG.error(e.getLocalizedMessage(), e);
                        }
                    }
                } else if (CmsUser.hasPrefix(key)) {
                    // read the user
                    principal = OpenCms.getImportExportManager().translateUser(principal);
                    try {
                        result = cms.getRequestContext().getCurrentUser().equals(cms.readUser(principal));
                    } catch (CmsException e) {
                        if (LOG.isErrorEnabled()) {
                            LOG.error(e.getLocalizedMessage(), e);
                        }
                    }
                } else if (CmsRole.hasPrefix(key)) {
                    // read the role with role name
                    CmsRole role = CmsRole.valueOfRoleName(principal);
                    if (role == null) {
                        // try to read the role in the old fashion with group name
                        role = CmsRole.valueOfGroupName(principal);
                    }
                    if (role != null) {
                        result = OpenCms.getRoleManager().hasRole(
                            cms,
                            role.forOrgUnit(cms.getRequestContext().getCurrentUser().getOuFqn()));
                    }
                }
                if (result) {
                    break;
                }
            }
        } else {
            result = OpenCms.getRoleManager().hasRole(cms, CmsRole.ELEMENT_AUTHOR);
        }
        return result;
    }
1159275
protected boolean isEditable() {

        if (m_isEditable == null) {

            if (getCms().getRequestContext().getCurrentProject().isOnlineProject()
                || !getCms().isInsideCurrentProject(getParamResource())) {
                // we are in the online project or resource does not belong to project, no editing allowed
                m_isEditable = Boolean.FALSE;

            } else {
                // we are in an offline project

                // check permissions
                if (!checkResourcePermissions(CmsPermissionSet.ACCESS_WRITE, false)) {
                    getSettings().setErrorMessage(null);
                    m_isEditable = Boolean.FALSE;
                    return m_isEditable.booleanValue();
                }

                // check lock state
                String resourceName = getParamResource();
                CmsResource file = null;
                CmsLock lock = null;
                try {
                    file = getCms().readResource(resourceName, CmsResourceFilter.ALL);
                    // check if resource is a folder
                    if (file.isFolder() && !resourceName.endsWith("/")) {
                        resourceName += "/";
                    }
                } catch (CmsException e) {
                    // should usually never happen
                    if (LOG.isInfoEnabled()) {
                        LOG.info(e.getLocalizedMessage());
                    }
                }

                try {
                    // get the lock for the resource
                    lock = getCms().getLock(file);
                } catch (CmsException e) {
                    lock = CmsLock.getNullLock();

                    if (LOG.isErrorEnabled()) {
                        LOG.error(e.getLocalizedMessage(), e);
                    }
                }

                if (!lock.isNullLock()) {
                    // determine if resource is editable...
                    if (lock.isDirectlyOwnedBy(getCms().getRequestContext().getCurrentUser())) {
                        // lock is exclusive and belongs to the current user
                        if (lock.isInProject(getCms().getRequestContext().getCurrentProject())
                            || Boolean.valueOf(getParamUsetempfileproject()).booleanValue()) {
                            // resource is locked in the current project or the tempfileproject is used
                            m_isEditable = Boolean.TRUE;
                            return m_isEditable.booleanValue();
                        }
                    }
                } else if (OpenCms.getWorkplaceManager().autoLockResources()) {
                    if ((file == null) || file.isFolder()) {
                        // check locked resources in folder
                        try {
                            List<String> lockedResources = getCms().getLockedResources(
                                resourceName,
                                CmsLockFilter.FILTER_ALL.filterNotOwnedByUserId(
                                    getCms().getRequestContext().getCurrentUser().getId()));
                            if (!lockedResources.isEmpty()) {
                                m_isEditable = Boolean.FALSE;
                                return m_isEditable.booleanValue();
                            }
                        } catch (CmsException e1) {
                            // should usually never happen
                            if (LOG.isErrorEnabled()) {
                                LOG.error(e1.getLocalizedMessage(), e1);
                            }
                        }
                    }
                    m_isEditable = Boolean.TRUE;
                    return m_isEditable.booleanValue();
                }
                // lock is null or belongs to other user and/or project, properties are not editable
                m_isEditable = Boolean.FALSE;
            }
        }
        return m_isEditable.booleanValue();
    }
1318787
private void checkIndices(int row, int col) {
        if (row < 0 || row >= rows)
            throw new ArrayIndexOutOfBoundsException("row: " + row);
        else if (col < 0 || col >= cols)
            throw new ArrayIndexOutOfBoundsException("column: " + col);
    }
105976
ImmutableCell<V> validateCounts(int rowCount, int columnCount) {
        if (row >= rowCount || column >= columnCount) {
            throw new IndexOutOfBoundsException("Invalid row-column: " + row + "," + column + " for grid " + rowCount + "x" + columnCount);
        }
        return this;
    }
850164
@Override
    protected boolean isColumnVisible(int colFlag) {

        if (colFlag == LIST_COLUMN_TYPEICON.hashCode()) {
            return true;
        }
        if (colFlag == LIST_COLUMN_NAME.hashCode()) {
            return true;
        }
        if (colFlag == CmsUserSettings.FILELIST_TITLE) {
            return true;
        }
        if (colFlag == CmsUserSettings.FILELIST_DATE_LASTMODIFIED) {
            return true;
        }
        return false;
    }
443552
private boolean isEditable() {

        String noEditReason = m_imageInfoProvider.get().getNoEditReason();
        boolean result = CmsStringUtil.isEmptyOrWhitespaceOnly(noEditReason);
        return result;
    }
349389
boolean isEditable(CmsObject cms, CmsResource resource) {

        try {
            return cms.hasPermissions(resource, CmsPermissionSet.ACCESS_WRITE, false, CmsResourceFilter.ALL);
        } catch (CmsException e) {
            return false;
        }
    }
1271255
protected function isSortable($column = null)
    {
        if ($column === null) {
            return (count($this->getSortableColumns()) > 0);
        }

        return array_key_exists($column, $this->getSortableColumns());
    }
287517
def BeginEdit(self, row, col, grid):
        

        # Disable if cell is locked, enable if cell is not locked
        grid = self.main_window.grid
        key = grid.actions.cursor

        locked = grid.code_array.cell_attributes[key]["locked"]or \
            grid.code_array.cell_attributes[key]["button_cell"]
        self._tc.Enable(not locked)
        self._tc.Show(not locked)

        if locked:
            grid.code_array.result_cache.clear()
            self._execute_cell_code(row, col, grid)

        # Mirror our changes onto the main_window's code bar
        self._tc.Bind(wx.EVT_CHAR, self.OnChar)
        self._tc.Bind(wx.EVT_KEY_UP, self.OnKeyUp)

        # Save cell and grid info
        self._row = row
        self._col = [col, ]  # List of columns we are occupying
        self._grid = grid

        start_value = grid.GetTable().GetValue(*key)

        try:
            start_value_list = [start_value[i:i+self.max_char_width]
                                for i in xrange(0, len(start_value),
                                                self.max_char_width)]
            startValue = "\n".join(start_value_list)
            self.startValue = startValue

        except TypeError:
            self.startValue = u""

        # Set up the textcontrol to look like this cell (TODO: Does not work)
        try:
            self._tc.SetValue(unicode(startValue))
        except (TypeError, AttributeError, UnboundLocalError):
            self._tc.SetValue(u"")

        self._tc.SetFont(grid.GetCellFont(row, col))
        self._tc.SetBackgroundColour(grid.GetCellBackgroundColour(row, col))
        self._update_control_length()

        self._tc.SetInsertionPointEnd()

        h_scroll_pos = grid.GetScrollPos(wx.SB_HORIZONTAL)
        v_scroll_pos = grid.GetScrollPos(wx.SB_VERTICAL)

        self._tc.SetFocus()

        # GTK Bugfix for jumping grid when focusing the textctrl
        if grid.GetScrollPos(wx.SB_HORIZONTAL) != h_scroll_pos or \
           grid.GetScrollPos(wx.SB_VERTICAL) != v_scroll_pos:
            wx.ScrolledWindow.Scroll(grid, (h_scroll_pos, v_scroll_pos))

        # Select the text
        self._tc.SetSelection(0, self._tc.GetLastPosition())
457853
public boolean containsRow(Map<String, String> row) {
        for (CsvRow csvRow : data) {
            if (csvRow.contains(row)) {
                return true;
            }
        }
        return false;
    }
413280
public boolean isCaseSensitive(int column) throws SQLException
    {
        sourceResultSet.checkColumnBounds(column);
        VoltType type = sourceResultSet.table.getColumnType(column - 1);
        return type.isCaseSensitive();
    }
1280916
@Override
    public void onValueUnRestricted(final String value) {
        this.restrictedColumns.remove(value);
        
        // Check single column used in data set -> it cannot be unselected.
        if (listEditor.getList().size() == 1) {
            setEditorEnabled(0 ,false, DataSetEditorConstants.INSTANCE.dataSetMustHaveAtLeastOneColumn());
        } else {
            setEditorEnabled(value, true, null);
        }
    }
1024187
@Override
    public boolean isCellEditable(EventObject anEvent) {
        if (anEvent instanceof MouseEvent) {
            return ((MouseEvent) anEvent).getClickCount() >= clickCountToEdit;
        }
        return true;
    }
1146593
public double getValueAtAsDouble(final int row, final int col) {
		final Object valueAt = getValueAt(row, col);
		double number = 0;
		if (valueAt != null && !valueAt.toString().equals("")) {
			number = Double.parseDouble(valueAt.toString().trim());
		}
		return number;
	}