Well, there has to be some kind of ordering for the data to be
displayed. It's just a matter of making your column model represent
that ordering, and allowing your row to interpret that ordering.
Remember that a column represents a "class" of data, not an "instance"
of data, so you can't have a separate model for every row. If you
want to do that, then you'll need to go back to using t:dataList and
implement your own t:columns-like object.
On 11/8/05, Enrique Medina <[EMAIL PROTECTED]> wrote:
> Put it another way...
>
> It would be nice to be able to put a data model for the <t:columns> tag for
> each row, but as only it can be set once, how can I define an id reference
> to any of the child objects?
>
> 2005/11/8, Enrique Medina <[EMAIL PROTECTED]>:
> > The problem here is that my collection is a set, but as I can only specify
> once in the value of the <t:columns> tag the data model, I can't see how can
> I get the exact identifier of the child object being modified.
> >
> > I mean, I only have one data model to populate the <t:columns>, but
> elements in each child collection of each row have distinct identifiers...
> >
> >
> >
> > 2005/11/8, Mike Kienenberger < [EMAIL PROTECTED]>:
> > > There's no right answer; there are many solutions. It just has to be
> > > something that you can use to look up the column value for the row
> > > object.
> > >
> > > From what you've said before, one possibility is to use a column data
> > > model that contains the Integers 0 to 7 (or MaxPrivs-1).
> > >
> > > Then you can use
> > >
> > > Object row = rowDataModel.getRowData()
> > > Number indexNumber =
> (Number)columnDataModel.getRowData()
> > > Object row.columnValueAtIndex (indexNumber);
> > >
> > > On 11/8/05, Enrique Medina <[EMAIL PROTECTED]> wrote:
> > > > I understand, but there is still something I cannot see...
> > > >
> > > > You use a data model as value to the <t:columns> tag, and then that
> data
> > > > model is used to identify the column selected. So my question is: what
> kind
> > > > of data model should I use so later any of my child objects can be
> > > > identified?
> > > >
> > > > 2005/11/8, Mike Kienenberger < [EMAIL PROTECTED]>:
> > > > > In my example, the columns were independent of the rows.
> > > > >
> > > > > In your case, you'll have to first compute the maximum size.
> > > > >
> > > > > Using my code, I'd do it something like this:
> > > > >
> > > > > ==============
> > > > > private columnList = null;
> > > > >
> > > > > public List getColumnList() {
> > > > > if (null == columnList) {
> > > > > List rowList = getRowList();
> > > > > // iterate over the row list and determine the value for
> > > > > maxColumnCount
> > > > > columnList =
> > > > createColumnListOfSize(maxColumnCount);
> > > > > }
> > > > >
> > > > > return columnList;
> > > > > }
> > > > >
> > > > > public boolean getValueFor(Object rowObject, Object columnObject) {
> > > > > int columnIndex = columnObject.findIndex ();
> > > > > if (columnIndex >= rowObject.getColumnList.size ()) return
> > > > emptyObject;
> > > > > else return rowObject.getColumnList(columnIndex);
> > > > > }
> > > > > ==============
> > > > >
> > > > > Obviously, my model isn't a direct fit to what you're doing, but the
> > > > > basic logic is still the same. The first time you need it, compute
> > > > > the max-size column list. Then each time a row/column item is
> > > > > accessed, return the column in the row if the row has that many
> > > > > elements, or return an empty object if it doesn't.
> > > > >
> > > > > -Mike
> > > > >
> > > > > On 11/7/05, Enrique Medina < [EMAIL PROTECTED]> wrote:
> > > > > > But what should I use in my example as "value" in the <t:columns>
> tag? I
> > > > > > mean, how can I ensure that for each row each of the child objects
> will
> > > > be
> > > > > > called? How does JSF knows it?
> > > > > >
> > > > > >
> > > > > > 2005/11/7, Mike Kienenberger < [EMAIL PROTECTED]>:
> > > > > > > My suggestion would be to adjust your column model so it always
> has 8
> > > > > > > (or MAX) values for each row, and simply return "empty"
> (whatever that
> > > > > > > means in your component) data for the remaining values.
> > > > > > >
> > > > > > > Alternatively, you could try:
> > > > > > >
> > > > > > > <t:columns>
> > > > > > > <h:panelgroup>
> > > > > > > <UIInput rendered="#{!column.empty}">
> > > > > > > <h:outputText value="" rendered="#{ column.empty }">
> > > > > > > </h:panelgroup>
> > > > > > > </t:columns>
> > > > > > >
> > > > > > > On 11/7/05, Enrique Medina < [EMAIL PROTECTED]> wrote:
> > > > > > > > Just to clarify with a concrete example:
> > > > > > > >
> > > > > > > > Imagine in your example of users and privileges that you want
> to
> > > > show
> > > > > > as
> > > > > > > > rows the users' names, and as columns simply each user's
> privileges,
> > > > but
> > > > > > the
> > > > > > > > first user (row) has 3 privileges, the second one has 5, the
> third
> > > > one
> > > > > > has 8
> > > > > > > > and the fourth one has 2. The maximum columns will be 8 (as of
> the
> > > > max
> > > > > > > > number of privileges per user), but not all the columns in all
> the
> > > > rows
> > > > > > will
> > > > > > > > be printed...
> > > > > > > >
> > > > > > > > 2005/11/7, Enrique Medina < [EMAIL PROTECTED] >:
> > > > > > > > > Great approach!
> > > > > > > > >
> > > > > > > > > Just one comment: while your dynamic number of columns
> > > > > > (allPrivilegeList)
> > > > > > > > is known, mine is not known, and depends as commented before
> on the
> > > > > > maximum
> > > > > > > > size of the collections of the parent objects. For example, in
> your
> > > > > > example,
> > > > > > > > instead of showing all the possible values of the privileges
> as
> > > > column
> > > > > > > > headers and then showing whether the user has the privilege or
> not,
> > > > > > imagine
> > > > > > > > my approach: you need to have as many columns as the maximum
> > > > elements in
> > > > > > any
> > > > > > > > of the collections of the parent objects that populate the
> data
> > > > table.
> > > > > > > > >
> > > > > > > > > Do you know what I mean?
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > 2005/11/7, Mike Kienenberger < [EMAIL PROTECTED] >:
> > > > > > > > > > I always point out this example code I made as an example
> of
> > > > > > creating
> > > > > > > > > > a composite component, but it also has a good example of
> using a
> > > > > > > > > > combined row&column data model.
> > > > > > > > > >
> > > > > > > > > > Take a look at
> > > > RowAndColumnRelationshipsBackingBean
> > > > > > > > which provides the
> > > > > > > > > > row model and the column model. I then implement the
> interface
> > > > in
> > > > > > > > > > RowAndColumnRelationshipsDataModel and
> can plug
> > > > any
> > > > > > > > number of models
> > > > > > > > > > into my page.
> > > > > > > > > >
> > > > > > > > > > I no longer use any of the other classes since I've
> switched
> > > > over to
> > > > > > > > facelets.
> > > > > > > > > > Instead, I now just use this page code. I've removed some
> of
> > > > the
> > > > > > > > > > decorations (like the dataScrollers), but these three
> files
> > > > > > > > > > (RowAndColumnRelationshipsBackingBean,
> > > > > > > > > > RowAndColumnRelationshipsDataModel, and
> the
> > > > code
> > > > > > below)
> > > > > > > > should
> > > > > > > > > > demonstrate it sufficiently.
> > > > > > > > > >
> > > > > > > > > > This level of indirection might be overkill for what
> you're
> > > > doing,
> > > > > > so
> > > > > > > > > > you might simply rewrite how
> > > > > > > > RowAndColumnRelationshipsBackingBean
> > > > > > > > > > works internally.
> > > > > > > > > >
> > > > > > > > > > "backingBean" is a
> > > > > > RowAndColumnRelationshipsBackingBean
> > > > > > > > configured
> > > > > > > > > > with another bean that implements a
> > > > > > > > > > RowAndColumnRelationshipsDataModel.
> > > > > > > > > >
> > > > > > > > > > <x:dataTable id="datatable"
> > > > > > > > > >
> > > > > > value="#{backingBean.rowDataModel }"
> > > > > > > > > > var="row"
> > > > > > > > > >
> > > > preserveDataModel="false"
> > > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > > <f:facet name="footer">
> > > > > > > > > > <h:panelGroup>
> > > > > > > > > > <h:commandButton value="Update"
> > > > > > > > > > actionListener="#{backingBean.update}"/>
> > > > > > > > > > </h:panelGroup>
> > > > > > > > > > </f:facet>
> > > > > > > > > > <h:column>
> > > > > > > > > > <h:outputText value="#{row.rowName}"/>
> > > > > > > > > > </h:column>
> > > > > > > > > > <x:columns
> > > > > > > > > > value="#{backingBean.columnDataModel}"
> > > > > > > > > > var="column">
> > > > > > > > > > <f:facet name="header">
> > > > > > > > > > <h:outputText
> value="#{column.columnName}"/>
> > > > > > > > > > </f:facet>
> > > > > > > > > > <h:selectBooleanCheckbox
> > > > > > > > > > value="#{backingBean.relationshipValue }"/>
> > > > > > > > > > </x:columns>
> > > > > > > > > > </x:dataTable>
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > > On 11/7/05, Enrique Medina < [EMAIL PROTECTED]> wrote:
> > > > > > > > > > > I understand Mike :-)
> > > > > > > > > > >
> > > > > > > > > > > So if I have a collection of parent objects, which in
> turn
> > > > each
> > > > > > > > parent
> > > > > > > > > > > object has a collection of other child objects, then I
> can
> > > > show a
> > > > > > > > table
> > > > > > > > > > > where the first column is fixed and contains vertically
> the
> > > > list
> > > > > > of
> > > > > > > > the
> > > > > > > > > > > parent objects, but for each row, the columns are
> dynamic and
> > > > can
> > > > > > show
> > > > > > > > the
> > > > > > > > > > > collection of child objects for each parent. Is that
> right?
> > > > > > > > > > >
> > > > > > > > > > > What should I use for each data model, I mean, the
> collection
> > > > of
> > > > > > > > parent
> > > > > > > > > > > objects to populate the main data table and the child
> > > > collection
> > > > > > of
> > > > > > > > each
> > > > > > > > > > > parent object to populate the columns component? Would
> that
> > > > make
> > > > > > > > sense? If I
> > > > > > > > > > > edit all the child objects, would the getRowData from
> the main
> > > > > > table
> > > > > > > > return
> > > > > > > > > > > me a parent object with its colllection modified so I
> could
> > > > > > rapidly
> > > > > > > > persist
> > > > > > > > > > > it?
> > > > > > > > > > >
> > > > > > > > > > > Thanks for your support ;-)
> > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > > 2005/11/7, Mike Kienenberger < [EMAIL PROTECTED]>:
> > > > > > > > > > > > t:columns does exactly that -- it takes a collection
> of data
> > > > and
> > > > > > > > makes
> > > > > > > > > > > > as many columns as items in the collection.
> > > > > > > > > > > >
> > > > > > > > > > > > In fact, you can think of t:columns as a data table
> rotated
> > > > 90
> > > > > > > > degrees.
> > > > > > > > > > > > The t:columns component, like dataTable is a subclass
> of
> > > > UIData.
> > > > > > > > The
> > > > > > > > > > > > "trick" is that when t:columns renders a "row" it uses
> <td>
> > > > > > instead
> > > > > > > > of
> > > > > > > > > > > > <tr>. It's not quite that simple, but from the
> perspective
> > > > of
> > > > > > an
> > > > > > > > > > > > end-user, it can be treated as such.
> > > > > > > > > > > >
> > > > > > > > > > > > In fact, t:columns API is a little bit confusing since
> > > > > > getRowData()
> > > > > > > > > > > > really means getColumnData and getRowIndex() really
> means
> > > > > > > > > > > > getColumnIndex(). Again, that's because it's
> effectively a
> > > > > > nested
> > > > > > > > > > > > dataTable that renders td tags instead of tr tags.
> > > > > > > > > > > >
> > > > > > > > > > > > I hope that helps!
> > > > > > > > > > > >
> > > > > > > > > > > > On 11/7/05, Enrique Medina < [EMAIL PROTECTED] >
> wrote:
> > > > > > > > > > > > > Well, maybe I have explained myself badly, but
> obviously
> > > > the
> > > > > > > > number of
> > > > > > > > > > > rows,
> > > > > > > > > > > > > although dynamic, would be fixed ( i.e. the maximum
> of
> > > > all).
> > > > > > > > > > > > >
> > > > > > > > > > > > > The main problem I have is that the data for the
> columns
> > > > is a
> > > > > > > > > > > collection
> > > > > > > > > > > > > rather than a fixed number of properties in a class;
> i.e .
> > > > it
> > > > > > > > represents
> > > > > > > > > > > an
> > > > > > > > > > > > > object with a collection of objects inside it, and
> each
> > > > > > element of
> > > > > > > > the
> > > > > > > > > > > > > collection is the data I want to show for every
> column.
> > > > > > > > > > > > >
> > > > > > > > > > > > > 2005/11/7, Mike Kienenberger < [EMAIL PROTECTED]>:
> > > > > > > > > > > > > > I don't know of a component that generates a
> different
> > > > > > number of
> > > > > > > > > > > > > > columns for each row. Columns allows a dynamic
> number
> > > > of
> > > > > > > > columns,
> > > > > > > > > > > > > > but the number is still the same for every row.
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > What kind of html would you expect it to generate,
> since
> > > > a
> > > > > > > > standard
> > > > > > > > > > > > > > html table expects a set number of columns?
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > Probably, your best bet is to go with a t:dataList
> which
> > > > > > > > operates on
> > > > > > > > > > > > > > row data, but doesn't render any particular
> output.
> > > > Then,
> > > > > > for
> > > > > > > > each
> > > > > > > > > > > > > > row, you can output whatever kind of html that you
> need.
> > > > > > > > > > > > > >
> > > > > > > > > > > > > > On 11/7/05, Enrique Medina < [EMAIL PROTECTED]
> >
> > > > wrote:
> > > > > > > > > > > > > > > Hi,
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > I want to create a special data table where the
> > > > number of
> > > > > > > > columns
> > > > > > > > > > > is
> > > > > > > > > > > > > > > variable in each row depending of the value of
> the
> > > > object
> > > > > > > > being
> > > > > > > > > > > painted.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > I've been looking at the HtmlColumns component,
> but
> > > > > > although
> > > > > > > > being
> > > > > > > > > > > > > dynamic,
> > > > > > > > > > > > > > > I can't see how I can define different number of
> > > > columns
> > > > > > for
> > > > > > > > each
> > > > > > > > > > > row.
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > > > Any idea of how to accomplish this kind of data
> > > > sheet?
> > > > > > > > > > > > > > >
> > > > > > > > > > > > > >
> > > > > > > > > > > > >
> > > > > > > > > > > > >
> > > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > >
> > > > > > > >
> > > > > > >
> > > > > >
> > > > > >
> > > > >
> > > >
> > > >
> > >
> >
> >
>
>
