/** * Returns a new instance of the default renderer for the specified class. * This differs from <code>getDefaultRenderer()</code> in that it returns a * <b>new </b> instance each time so that the renderer may be set and * customized on a particular column. * <p> * * NOTE: this doesn't work with swingx renderers! Do we really need it? It * had been used in JNTable which is practically obsolete. If needed, we * could make all renderer support classes clonable. * * @param columnClass Class of value being rendered * @return TableCellRenderer instance which renders values of the specified * type * @see #getDefaultRenderer(Class) */ public TableCellRenderer getNewDefaultRenderer(Class<?> columnClass) { TableCellRenderer renderer = getDefaultRenderer(columnClass); if (renderer != null) { try { return renderer.getClass().newInstance(); } catch (Exception e) { LOG.fine("could not create renderer for " + columnClass); } } // JW PENDING: must not return null! return null; }
/** * {@inheritDoc} * <p> * * Overridden to fix core bug #4614616 (NPE if <code>TableModel</code>'s * <code>Class</code> for the column is an interface). This method * guarantees to always return a <code>not null</code> value. Returns the * default renderer for <code>Object</code> if super returns * <code>null</code>. * * */ @Override public TableCellRenderer getCellRenderer(int row, int column) { TableCellRenderer renderer = super.getCellRenderer(row, column); if (renderer == null) { renderer = getDefaultRenderer(Object.class); } return renderer; }
/** * {@inheritDoc} * <p> * * Overridden to fix core bug #4614616 (NPE if <code>TableModel</code>'s * <code>Class</code> for the column is an interface). This method * guarantees to always return a <code>not null</code> value. Returns the * default renderer for <code>Object</code> if super returns * <code>null</code>.<p> * * <b>Note</b>: The lookup strategy for is unchanged compared to super. Subclasses * which override this with a different lookup strategy are strongly advised to * implement a custom StringValueRegistry with that lookup strategy to keep * the WYSIWYM in SwingX. * */ @Override public TableCellRenderer getCellRenderer(int row, int column) { TableCellRenderer renderer = super.getCellRenderer(row, column); if (renderer == null) { renderer = getDefaultRenderer(Object.class); } return renderer; }
/** * {@inheritDoc} * <p> * * Overridden to fix core bug #4614616 (NPE if <code>TableModel</code>'s * <code>Class</code> for the column is an interface). This method * guarantees to always return a <code>not null</code> value. Returns the * default renderer for <code>Object</code> if super returns * <code>null</code>.<p> * * <b>Note</b>: The lookup strategy for is unchanged compared to super. Subclasses * which override this with a different lookup strategy are strongly advised to * implement a custom StringValueRegistry with that lookup strategy to keep * the WYSIWYM in SwingX. * */ @Override public TableCellRenderer getCellRenderer(int row, int column) { TableCellRenderer renderer = super.getCellRenderer(row, column); if (renderer == null) { renderer = getDefaultRenderer(Object.class); } return renderer; }
/** * {@inheritDoc} * <p> * * Overridden to fix core bug #4614616 (NPE if <code>TableModel</code>'s * <code>Class</code> for the column is an interface). This method * guarantees to always return a <code>not null</code> value. Returns the * default renderer for <code>Object</code> if super returns * <code>null</code>.<p> * * <b>Note</b>: The lookup strategy for is unchanged compared to super. Subclasses * which override this with a different lookup strategy are strongly advised to * implement a custom StringValueRegistry with that lookup strategy to keep * the WYSIWYM in SwingX. * */ @Override public TableCellRenderer getCellRenderer(int row, int column) { TableCellRenderer renderer = super.getCellRenderer(row, column); if (renderer == null) { renderer = getDefaultRenderer(Object.class); } return renderer; }
/** * {@inheritDoc} * <p> * * Overridden to fix core bug #4614616 (NPE if <code>TableModel</code>'s * <code>Class</code> for the column is an interface). This method * guarantees to always return a <code>not null</code> value. Returns the * default renderer for <code>Object</code> if super returns * <code>null</code>.<p> * * <b>Note</b>: The lookup strategy for is unchanged compared to super. Subclasses * which override this with a different lookup strategy are strongly advised to * implement a custom StringValueRegistry with that lookup strategy to keep * the WYSIWYM in SwingX. * */ @Override public TableCellRenderer getCellRenderer(int row, int column) { TableCellRenderer renderer = super.getCellRenderer(row, column); if (renderer == null) { renderer = getDefaultRenderer(Object.class); } return renderer; }
/** * Returns a suitable renderer for the column index in model * coordinates. * * PENDING JW: this duplicates this table's lookup code if column is not * visible. That's not good enough if subclasses implemented a different * strategy! We do it anyway for now, mostly we will be lucky and * improve the situation against using toString always. * * @param column the columnIndex in model coordinates * @return a renderer suitable for rendering cells in the given column */ private TableCellRenderer getRendererByModelColumn(int column) { // PENDING JW: here we are tricksing - duplicating JXTable renderer // lookup strategy // that's inherently unsafe, as subclasses may decide to do it // differently TableColumn tableColumn = getColumnByModelIndex(column); TableCellRenderer renderer = tableColumn.getCellRenderer(); if (renderer == null) { renderer = table.getDefaultRenderer(table.getModel() .getColumnClass(column)); } if (renderer == null) { renderer = table.getDefaultRenderer(Object.class); } return renderer; }
.getDefaultRenderer(String.class);
.getDefaultRenderer(String.class);
.getDefaultRenderer(String.class);
.getDefaultRenderer(String.class);
/** * Returns the cell renderer to use for measuring. Delegates to * JXTable for visible columns, duplicates table logic for hidden * columns. <p> * * @param table the table which provides the renderer * @param columnExt the TableColumn to configure * * @return returns a cell renderer for measuring. */ protected TableCellRenderer getCellRenderer(JXTable table, TableColumnExt columnExt) { int viewIndex = table.convertColumnIndexToView(columnExt .getModelIndex()); if (viewIndex >= 0) { // JW: ok to not guard against rowCount < 0? // technically, the index should be a valid coordinate return table.getCellRenderer(0, viewIndex); } // hidden column - need api on JXTable to access renderer for hidden? // here we duplicate JXTable api ... maybe by-passing the strategy // implemented there TableCellRenderer renderer = columnExt.getCellRenderer(); if (renderer == null) { renderer = table.getDefaultRenderer(table.getModel().getColumnClass(columnExt.getModelIndex())); } return renderer; }
/** * Returns the cell renderer to use for measuring. Delegates to * JXTable for visible columns, duplicates table logic for hidden * columns. <p> * * @param table the table which provides the renderer * @param columnExt the TableColumn to configure * * @return returns a cell renderer for measuring. */ protected TableCellRenderer getCellRenderer(JXTable table, TableColumnExt columnExt) { int viewIndex = table.convertColumnIndexToView(columnExt .getModelIndex()); if (viewIndex >= 0) { // JW: ok to not guard against rowCount < 0? // technically, the index should be a valid coordinate return table.getCellRenderer(0, viewIndex); } // hidden column - need api on JXTable to access renderer for hidden? // here we duplicate JXTable api ... maybe by-passing the strategy // implemented there TableCellRenderer renderer = columnExt.getCellRenderer(); if (renderer == null) { renderer = table.getDefaultRenderer(table.getModel().getColumnClass(columnExt.getModelIndex())); } return renderer; }
/** * Returns the cell renderer to use for measuring. Delegates to * JXTable for visible columns, duplicates table logic for hidden * columns. <p> * * @param table the table which provides the renderer * @param columnExt the TableColumn to configure * * @return returns a cell renderer for measuring. */ protected TableCellRenderer getCellRenderer(JXTable table, TableColumnExt columnExt) { int viewIndex = table.convertColumnIndexToView(columnExt .getModelIndex()); if (viewIndex >= 0) { // JW: ok to not guard against rowCount < 0? // technically, the index should be a valid coordinate return table.getCellRenderer(0, viewIndex); } // hidden column - need api on JXTable to access renderer for hidden? // here we duplicate JXTable api ... maybe by-passing the strategy // implemented there TableCellRenderer renderer = columnExt.getCellRenderer(); if (renderer == null) { renderer = table.getDefaultRenderer(table.getModel().getColumnClass(columnExt.getModelIndex())); } return renderer; }
/** * Returns the cell renderer to use for measuring. Delegates to * JXTable for visible columns, duplicates table logic for hidden * columns. <p> * * @param table the table which provides the renderer * @param columnExt the TableColumn to configure * * @return returns a cell renderer for measuring. */ protected TableCellRenderer getCellRenderer(JXTable table, TableColumnExt columnExt) { int viewIndex = table.convertColumnIndexToView(columnExt .getModelIndex()); if (viewIndex >= 0) { // JW: ok to not guard against rowCount < 0? // technically, the index should be a valid coordinate return table.getCellRenderer(0, viewIndex); } // hidden column - need api on JXTable to access renderer for hidden? // here we duplicate JXTable api ... maybe by-passing the strategy // implemented there TableCellRenderer renderer = columnExt.getCellRenderer(); if (renderer == null) { renderer = table.getDefaultRenderer(table.getModel().getColumnClass(columnExt.getModelIndex())); } return renderer; }
/** * Returns the cell renderer to use for measuring. Delegates to * JXTable for visible columns, duplicates table logic for hidden * columns. <p> * * @param table the table which provides the renderer * @param columnExt the TableColumn to configure * * @return returns a cell renderer for measuring. */ protected TableCellRenderer getCellRenderer(JXTable table, TableColumnExt columnExt) { int viewIndex = table.convertColumnIndexToView(columnExt .getModelIndex()); if (viewIndex >= 0) { // JW: ok to not guard against rowCount < 0? // technically, the index should be a valid coordinate return table.getCellRenderer(0, viewIndex); } // hidden column - need api on JXTable to access renderer for hidden? // here we duplicate JXTable api ... maybe by-passing the strategy // implemented there TableCellRenderer renderer = columnExt.getCellRenderer(); if (renderer == null) { renderer = table.getDefaultRenderer(table.getModel().getColumnClass(columnExt.getModelIndex())); } return renderer; }
final Renderers renderers = Renderers.getInstance(otrosApplication); table.setDefaultRenderer(String.class, new TableMarkDecoratorRenderer(renderers.getStringRenderer())); table.setDefaultRenderer(Object.class, new TableMarkDecoratorRenderer(table.getDefaultRenderer(Object.class))); table.setDefaultRenderer(Integer.class, new TableMarkDecoratorRenderer(table.getDefaultRenderer(Object.class))); table.setDefaultRenderer(Level.class, new TableMarkDecoratorRenderer(renderers.getLevelRenderer())); table.setDefaultRenderer(Date.class, new TableMarkDecoratorRenderer(renderers.getDateRenderer())); table.setDefaultRenderer(Boolean.class, new TableMarkDecoratorRenderer(table.getDefaultRenderer(Boolean.class))); table.setDefaultRenderer(Note.class, new TableMarkDecoratorRenderer(new NoteRenderer())); table.setDefaultRenderer(MarkerColors.class, new TableMarkDecoratorRenderer(new MarkTableRenderer()));