ReportNet How-To:  Formatting a List Report into Page-Columns

1. Create your base list report using a query called “Base.”
   
   1. Lay out your rows carefully.  You must be sure that the each row in your list will always take up the same amount of vertical space on the page.  That is, each row must take up one line, or each row must take up two lines, etc.  If some rows are one line and some are two (i.e. if the vertical space can vary depending on how much data is in the row, such as when text wraps to a second line), then this technique will not work. Also, you may not use group headers and footers in your list.  If you do, this technique will not work.
   2. In the List properties, set the “Contents Height” property to “Minimal” and the “Column Titles” property to “At start of details.”
   3. Add all page headers and footers and adjust the page margins to the way you will want them in your final report.  Run the report to PDF format.  Make any adjustments to formatting so that your list is the way you want it to look before you proceed further. 
   4. Look at the widest row of data in your list and, based on that width, determine how many page-columns will fit across the page.  Call this number “pagecolumns”.  For this example, pagecolumns = 3.
   5. Count the number of rows that fit on the page in the current layout.  Call this number “columnrows.”  For this example, columnrows = 54.
      
      
2. Add two calculated fields in the tabular model and query for “Base”:
   
   1. rownum: running-count([PERSON_UID])  (or any column in the list).  This will produce a straight running count of every row in the list beginning with 1.
   2. mod: mod([rownum], pagecolumns * columnrows)  For this example the formula is mod([rownum], 3 * 54).  The mod function returns the remainder after dividing the first argument by the second argument.  When using [rownum] as the first argument and pagecolumns * columnrows as the second argument, what this will result in is a straight running count that will count from 1 up through the second argument minus 1 (in this case (3 * 54) - 1 or 161), then start over at 0 and count up to 161 again, and so on until all the rows are counted.  162 (zero through 161) is the total number of rows that will appear on one page (3 page-columns * 54 column rows). 
   3. Bring [rownum] and [mod] data elements into the “Base” query.
      
      
3. Create copies of “Base” for each page-column you want to create:
   
   1. In this example, we will have three new queries because we want three page-columns.  Name them PageCol1, PageCol2, etc.
   2. Into the “Children” area of the tabular model for each query, drag a Tabular Reference object, and set the “Query” property for the Tabular Reference object to “Base.”  This is simply a shortcut to avoid having to re-create the same tabular model for each of the new queries.
      
      
4. Define each page-column query to return only the rows that should show in that page-column.
   
   1. Open the tabular model for PageCol1 and drag a filter object into it.  Define the filter for [mod] between 1 and columnrows (in this example, [mod] between 1 and 54).  This will cause only the first 54 rows of each set of 162 to be returned by this query.
   2. Open the tabular model for PageCol2 and drag a filter object into it.  Define the filter for [mod] between columnrows + 1 and columnrows * 2 (in this example, [mod] between 55 and 108).  This will cause only rows 55 through 108 in each set of 162 to be returned by this query.
   3. Repeat for each additional page-column query, defining a filter that will return the only the next set of rows out of the total set for the page.  Note that for the last page-column query, you will have to include rows where [mod] = 0, because the 162nd row will have mod 0.  This will be the last list row in the last page-column on each page.  In this example, our third and last page-column query will include the filter [mod] = 0 or [mod] between 109 and 161.
      
      
5. Set up your report to display identical lists for each page-column, each one referencing the query that returns only the correct rows for that page-column.
   
   1. Drag a table object to your report page that has one row, and as many columns as you want page-columns.  In this example, the table is one row by three columns.
   2. Set the Table object’s “Size & Overflow” property to “Width = 100%”.  This will equally divide the available space across the page for your columns.
   3. Cut the finished list object you created in Step 1 (which currently references the query “Base”), and paste it into the first cell of the table.
   4. Copy the same list object and paste it into each of the remaining table cells.  You now have a table containing identical list objects in each table cell.
   5. Change the query property of each list object so that it refers to the “TableCol” query that applies to that lists’ page-column.  So, for the first list, change the Query property to TableCol1; for the second, to TableCol2; etc.
      
      
6. You’re done. 
   
   1.  In this example, for each set of 162 rows, page-column 1 will display rows 1 through 55; page-column 2 will display rows 56 through 108; and page-column 3 will display rows 109 through 162.  The sequence will start over again on the next page:  The 163rd row has [mod] = 1, so it will be the first row in the first column on page 2; the 217th row will have [mod] = 55, so it will be the first row in the second column on the page 2; and the 271st row will have [mod] = 109, so it will be the first row in the third column on page 2; and so on for all remaining rows and pages in the report.
   2. Understanding this helps you to understand why the number of columns per page and the number of rows per column must be pre-determined, and must not vary throughout the report; otherwise these formulas cannot work consistently for every column and every page, and you will wind up either repeating rows between columns, or omitting rows completely.