Don't get the Date twice from the ResultSet.
[online-glom:gwt-glom.git] / src / main / java / org / glom / web / server / OnlineGlomServiceImpl.java
1 /*
2  * Copyright (C) 2010, 2011 Openismus GmbH
3  *
4  * This file is part of GWT-Glom.
5  *
6  * GWT-Glom is free software: you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as published by the
8  * Free Software Foundation, either version 3 of the License, or (at your
9  * option) any later version.
10  *
11  * GWT-Glom is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
14  * for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with GWT-Glom.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 package org.glom.web.server;
21
22 import java.beans.PropertyVetoException;
23 import java.io.File;
24 import java.io.IOException;
25 import java.sql.Connection;
26 import java.sql.Date;
27 import java.sql.ResultSet;
28 import java.sql.SQLException;
29 import java.sql.Statement;
30 import java.sql.Time;
31 import java.text.DateFormat;
32 import java.text.NumberFormat;
33 import java.util.ArrayList;
34 import java.util.Currency;
35 import java.util.Locale;
36 import java.util.Properties;
37
38 import org.glom.libglom.BakeryDocument.LoadFailureCodes;
39 import org.glom.libglom.Document;
40 import org.glom.libglom.Field;
41 import org.glom.libglom.FieldFormatting;
42 import org.glom.libglom.FieldVector;
43 import org.glom.libglom.Glom;
44 import org.glom.libglom.LayoutFieldVector;
45 import org.glom.libglom.LayoutGroupVector;
46 import org.glom.libglom.LayoutItem;
47 import org.glom.libglom.LayoutItemVector;
48 import org.glom.libglom.LayoutItem_Field;
49 import org.glom.libglom.NumericFormat;
50 import org.glom.libglom.SortClause;
51 import org.glom.libglom.SortFieldPair;
52 import org.glom.libglom.StringVector;
53 import org.glom.web.client.OnlineGlomService;
54 import org.glom.web.shared.ColumnInfo;
55 import org.glom.web.shared.GlomDocument;
56 import org.glom.web.shared.GlomField;
57 import org.glom.web.shared.LayoutListTable;
58
59 import com.allen_sauer.gwt.log.client.Log;
60 import com.google.gwt.user.server.rpc.RemoteServiceServlet;
61 import com.mchange.v2.c3p0.ComboPooledDataSource;
62 import com.mchange.v2.c3p0.DataSources;
63
64 @SuppressWarnings("serial")
65 public class OnlineGlomServiceImpl extends RemoteServiceServlet implements OnlineGlomService {
66         private Document document = null;
67         private ComboPooledDataSource cpds = null;
68         // TODO implement locale
69         private final Locale locale = Locale.ROOT;
70         private boolean configured = false;
71
72         /*
73          * This is called when the servlet is started or restarted.
74          */
75         public OnlineGlomServiceImpl() {
76                 Glom.libglom_init();
77         }
78
79         /*
80          * The properties file can't be loaded in the constructor because the servlet is not yet initialised and
81          * getServletContext() will return null. The work-around for this problem is to initialise the database and glom
82          * document object when makes its first request.
83          */
84         private void configureServlet() {
85                 document = new Document();
86
87                 Properties props = new Properties();
88                 String propFileName = "/WEB-INF/OnlineGlom.properties";
89                 try {
90                         props.load(getServletContext().getResourceAsStream(propFileName));
91                 } catch (IOException e) {
92                         Log.fatal("Error loading " + propFileName, e);
93                         // TODO can't continue, notify user of problem
94                 }
95
96                 File file = new File(props.getProperty("glomfile"));
97                 document.set_file_uri("file://" + file.getAbsolutePath());
98                 int error = 0;
99                 boolean retval = document.load(error);
100                 if (retval == false) {
101                         String message;
102                         if (LoadFailureCodes.LOAD_FAILURE_CODE_NOT_FOUND == LoadFailureCodes.swigToEnum(error)) {
103                                 message = "Could not find " + file.getAbsolutePath();
104                         } else {
105                                 message = "An unknown error occurred when trying to load " + file.getAbsolutePath();
106                         }
107                         Log.fatal(message);
108                         // TODO can't continue, notify user of problem
109                 }
110
111                 // load the jdbc driver
112                 cpds = new ComboPooledDataSource();
113                 try {
114                         cpds.setDriverClass("org.postgresql.Driver");
115                 } catch (PropertyVetoException e) {
116                         Log.fatal("Error loading the PostgreSQL JDBC driver. Is the PostgreSQL JDBC jar available to the servlet?",
117                                         e);
118                         // TODO can't continue, notify user of problem
119                 }
120
121                 cpds.setJdbcUrl("jdbc:postgresql://" + document.get_connection_server() + "/"
122                                 + document.get_connection_database());
123                 cpds.setUser(props.getProperty("dbusername"));
124                 cpds.setPassword(props.getProperty("dbpassword"));
125                 // TODO notify user if dbusername or dbpassword are wrong
126                 configured = true;
127         }
128
129         /*
130          * This is called when the servlet is stopped or restarted.
131          * 
132          * @see javax.servlet.GenericServlet#destroy()
133          */
134         @Override
135         public void destroy() {
136                 Glom.libglom_deinit();
137                 try {
138                         if (configured)
139                                 DataSources.destroy(cpds);
140                 } catch (SQLException e) {
141                         Log.error("Error cleaning up the ComboPooledDataSource", e);
142                 }
143         }
144
145         /*
146          * FIXME I think Swig is generating long on 64-bit machines and int on 32-bit machines - need to keep this constant
147          * http://stackoverflow.com/questions/1590831/safely-casting-long-to-int-in-java
148          */
149         private static int safeLongToInt(long l) {
150                 if (l < Integer.MIN_VALUE || l > Integer.MAX_VALUE) {
151                         throw new IllegalArgumentException(l + " cannot be cast to int without changing its value.");
152                 }
153                 return (int) l;
154         }
155
156         public GlomDocument getGlomDocument() {
157                 if (!configured)
158                         configureServlet();
159
160                 GlomDocument glomDocument = new GlomDocument();
161
162                 // get arrays of table names and titles, and find the default table index
163                 StringVector tablesVec = document.get_table_names();
164
165                 int numTables = safeLongToInt(tablesVec.size());
166                 // we don't know how many tables will be hidden so we'll use half of the number of tables for the default size
167                 // of the ArrayList
168                 ArrayList<String> tableNames = new ArrayList<String>(numTables / 2);
169                 ArrayList<String> tableTitles = new ArrayList<String>(numTables / 2);
170                 boolean foundDefaultTable = false;
171                 int visibleIndex = 0;
172                 for (int i = 0; i < numTables; i++) {
173                         String tableName = tablesVec.get(i);
174                         if (!document.get_table_is_hidden(tableName)) {
175                                 tableNames.add(tableName);
176                                 // JNI is "expensive", the comparison will only be called if we haven't already found the default table
177                                 if (!foundDefaultTable && tableName.equals(document.get_default_table())) {
178                                         glomDocument.setDefaultTableIndex(visibleIndex);
179                                         foundDefaultTable = true;
180                                 }
181                                 tableTitles.add(document.get_table_title(tableName));
182                                 visibleIndex++;
183                         }
184                 }
185
186                 // set everything we need
187                 glomDocument.setTableNames(tableNames);
188                 glomDocument.setTableTitles(tableTitles);
189                 glomDocument.setTitle(document.get_database_title());
190
191                 return glomDocument;
192         }
193
194         public LayoutListTable getLayoutListTable(String table) {
195                 if (!configured)
196                         configureServlet();
197
198                 LayoutListTable tableInfo = new LayoutListTable();
199
200                 // access the layout list
201                 LayoutGroupVector layoutListVec = document.get_data_layout_groups("list", table);
202                 ColumnInfo[] columns = null;
203                 LayoutFieldVector layoutFields = new LayoutFieldVector();
204                 int listViewLayoutGroupSize = safeLongToInt(layoutListVec.size());
205                 if (listViewLayoutGroupSize > 0) {
206                         // a layout list is defined, we can use it to for the LayoutListTable
207                         if (listViewLayoutGroupSize > 1)
208                                 Log.warn("The size of the list view layout group for table " + table
209                                                 + " is greater than 1. Attempting to use the first item for the layout list view.");
210                         LayoutItemVector layoutItemsVec = layoutListVec.get(0).get_items();
211
212                         // find the defined layout list fields
213                         int numItems = safeLongToInt(layoutItemsVec.size());
214                         columns = new ColumnInfo[numItems];
215                         for (int i = 0; i < numItems; i++) {
216                                 // TODO add support for other LayoutItems (Text, Image, Button)
217                                 LayoutItem item = layoutItemsVec.get(i);
218                                 LayoutItem_Field layoutItemField = LayoutItem_Field.cast_dynamic(item);
219                                 if (layoutItemField != null) {
220                                         layoutFields.add(layoutItemField);
221                                         FieldFormatting.HorizontalAlignment alignment = layoutItemField
222                                                         .get_formatting_used_horizontal_alignment();
223                                         columns[i] = new ColumnInfo(layoutItemField.get_title_or_name(),
224                                                         getColumnInfoHorizontalAlignment(alignment));
225                                 }
226                         }
227                 } else {
228                         // no layout list is defined, use the table fields as the layout list
229                         FieldVector fieldsVec = document.get_table_fields(table);
230
231                         // find the fields to display in the layout list
232                         int numItems = safeLongToInt(fieldsVec.size());
233                         columns = new ColumnInfo[numItems];
234                         for (int i = 0; i < numItems; i++) {
235                                 Field field = fieldsVec.get(i);
236                                 LayoutItem_Field layoutItemField = new LayoutItem_Field();
237                                 layoutItemField.set_full_field_details(field);
238                                 layoutFields.add(layoutItemField);
239                                 FieldFormatting.HorizontalAlignment alignment = layoutItemField
240                                                 .get_formatting_used_horizontal_alignment();
241                                 columns[i] = new ColumnInfo(layoutItemField.get_title_or_name(),
242                                                 getColumnInfoHorizontalAlignment(alignment));
243                         }
244                 }
245
246                 tableInfo.setColumns(columns);
247
248                 // Get the number of rows a query with the table name and layout fields would return. This is needed for the
249                 // list view pager.
250                 Connection conn = null;
251                 Statement st = null;
252                 ResultSet rs = null;
253                 try {
254                         // Setup and execute the count query. Special care needs to be take to ensure that the results will be based
255                         // on a cursor so that large amounts of memory are not consumed when the query retrieve a large amount of
256                         // data. Here's the relevant PostgreSQL documentation:
257                         // http://jdbc.postgresql.org/documentation/83/query.html#query-with-cursor
258                         conn = cpds.getConnection();
259                         conn.setAutoCommit(false);
260                         st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
261                         String query = Glom.build_sql_select_count_simple(table, layoutFields);
262                         // TODO Test execution time of this query with when the number of rows in the table is large (say >
263                         // 1,000,000). Test memory usage at the same time (see the todo item in getTableData()).
264                         rs = st.executeQuery(query);
265
266                         // get the number of rows in the query
267                         rs.next();
268                         tableInfo.setNumRows(rs.getInt(1));
269
270                 } catch (SQLException e) {
271                         Log.error("Error calculating number of rows in the query. Setting number of rows to 0.", e);
272                         tableInfo.setNumRows(0);
273                 } finally {
274                         // cleanup everything that has been used
275                         try {
276                                 rs.close();
277                                 st.close();
278                                 conn.close();
279                         } catch (Exception e) {
280                                 Log.error("Error closing database resources. Subsequent database queries may not work.", e);
281                         }
282                 }
283
284                 return tableInfo;
285         }
286
287         public ArrayList<GlomField[]> getTableData(String table, int start, int length) {
288                 return getTableData(table, start, length, false, 0, false);
289         }
290
291         public ArrayList<GlomField[]> getSortedTableData(String table, int start, int length, int sortColumnIndex,
292                         boolean isAscending) {
293                 return getTableData(table, start, length, true, sortColumnIndex, isAscending);
294         }
295
296         private ArrayList<GlomField[]> getTableData(String table, int start, int length, boolean useSortClause,
297                         int sortColumnIndex, boolean isAscending) {
298                 if (!configured)
299                         configureServlet();
300
301                 // access the layout list using the defined layout list or the table fields if there's no layout list
302                 LayoutGroupVector layoutListVec = document.get_data_layout_groups("list", table);
303                 LayoutFieldVector layoutFields = new LayoutFieldVector();
304                 SortClause sortClause = new SortClause();
305                 int listViewLayoutGroupSize = safeLongToInt(layoutListVec.size());
306                 if (layoutListVec.size() > 0) {
307                         // a layout list is defined, we can use it to for the LayoutListTable
308                         if (listViewLayoutGroupSize > 1)
309                                 Log.warn("The size of the list view layout group for table " + table
310                                                 + " is greater than 1. Attempting to use the first item for the layout list view.");
311                         LayoutItemVector layoutItemsVec = layoutListVec.get(0).get_items();
312
313                         // find the defined layout list fields
314                         int numItems = safeLongToInt(layoutItemsVec.size());
315                         for (int i = 0; i < numItems; i++) {
316                                 // TODO add support for other LayoutItems (Text, Image, Button)
317                                 LayoutItem item = layoutItemsVec.get(i);
318                                 LayoutItem_Field layoutItemfield = LayoutItem_Field.cast_dynamic(item);
319                                 if (layoutItemfield != null) {
320                                         // use this field in the layout
321                                         layoutFields.add(layoutItemfield);
322
323                                         // create a sort clause if it's a primary key and we're not asked to sort a specific column
324                                         if (!useSortClause) {
325                                                 Field details = layoutItemfield.get_full_field_details();
326                                                 if (details != null && details.get_primary_key()) {
327                                                         sortClause.addLast(new SortFieldPair(layoutItemfield, true)); // ascending
328                                                 }
329                                         }
330                                 }
331                         }
332                 } else {
333                         // no layout list is defined, use the table fields as the layout list
334                         FieldVector fieldsVec = document.get_table_fields(table);
335
336                         // find the fields to display in the layout list
337                         int numItems = safeLongToInt(fieldsVec.size());
338                         for (int i = 0; i < numItems; i++) {
339                                 Field field = fieldsVec.get(i);
340                                 LayoutItem_Field layoutItemField = new LayoutItem_Field();
341                                 layoutItemField.set_full_field_details(field);
342                                 layoutFields.add(layoutItemField);
343
344                                 // create a sort clause if it's a primary key and we're not asked to sort a specific column
345                                 if (!useSortClause) {
346                                         if (field.get_primary_key()) {
347                                                 sortClause.addLast(new SortFieldPair(layoutItemField, true)); // ascending
348                                         }
349                                 }
350                         }
351                 }
352
353                 // create a sort clause for the column we've been asked to sort
354                 if (useSortClause) {
355                         LayoutItem item = layoutFields.get(sortColumnIndex);
356                         LayoutItem_Field field = LayoutItem_Field.cast_dynamic(item);
357                         if (field != null)
358                                 sortClause.addLast(new SortFieldPair(field, isAscending));
359                         else {
360                                 Log.error("Error getting LayoutItem_Field for column index " + sortColumnIndex
361                                                 + ". Cannot create a sort clause for this column.");
362                         }
363
364                 }
365
366                 ArrayList<GlomField[]> rowsList = new ArrayList<GlomField[]>();
367                 Connection conn = null;
368                 Statement st = null;
369                 ResultSet rs = null;
370                 try {
371                         // Setup and execute the query. Special care needs to be take to ensure that the results will be based on a
372                         // cursor so that large amounts of memory are not consumed when the query retrieve a large amount of data.
373                         // Here's the relevant PostgreSQL documentation:
374                         // http://jdbc.postgresql.org/documentation/83/query.html#query-with-cursor
375                         conn = cpds.getConnection();
376                         conn.setAutoCommit(false);
377                         st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
378                         st.setFetchSize(length);
379                         String query = Glom.build_sql_select_simple(table, layoutFields, sortClause) + " OFFSET " + start;
380                         // TODO Test memory usage before and after we execute the query that would result in a large ResultSet.
381                         // We need to ensure that the JDBC driver is in fact returning a cursor based result set that has a low
382                         // memory footprint. Check the difference between this value before and after the query:
383                         // Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()
384                         // Test the execution time at the same time (see the todo item in getLayoutListTable()).
385                         rs = st.executeQuery(query);
386
387                         // get the data we've been asked for
388                         int rowCount = 0;
389                         while (rs.next() && rowCount <= length) {
390                                 int layoutFieldsSize = safeLongToInt(layoutFields.size());
391                                 GlomField[] rowArray = new GlomField[layoutFieldsSize];
392                                 for (int i = 0; i < layoutFieldsSize; i++) {
393                                         // make a new GlomField to set the text and colours
394                                         rowArray[i] = new GlomField();
395
396                                         // get foreground and background colours
397                                         LayoutItem_Field field = layoutFields.get(i);
398                                         FieldFormatting formatting = field.get_formatting_used();
399                                         String fgcolour = formatting.get_text_format_color_foreground();
400                                         if (!fgcolour.isEmpty())
401                                                 rowArray[i].setFGColour(convertGdkColorToHtmlColour(fgcolour));
402                                         String bgcolour = formatting.get_text_format_color_background();
403                                         if (!bgcolour.isEmpty())
404                                                 rowArray[i].setBGColour(convertGdkColorToHtmlColour(bgcolour));
405
406                                         // convert field values are to strings based on the glom type
407                                         switch (field.get_glom_type()) {
408                                         case TYPE_TEXT:
409                                                 String text = rs.getString(i + 1);
410                                                 rowArray[i].setText(text != null ? text : "");
411                                                 break;
412                                         case TYPE_BOOLEAN:
413                                                 rowArray[i].setText(rs.getBoolean(i + 1) ? "TRUE" : "FALSE");
414                                                 break;
415                                         case TYPE_NUMERIC:
416                                                 // Take care of the numeric formatting before converting the number to a string.
417                                                 NumericFormat numFormatGlom = formatting.getM_numeric_format();
418                                                 // There's no isCurrency() method in the glom NumericFormat class so we're assuming that the
419                                                 // number should be formatted as a currency if the currency code string is not empty.
420                                                 String currencyCode = numFormatGlom.getM_currency_symbol();
421                                                 NumberFormat numFormatJava = null;
422                                                 boolean useGlomCurrencyCode = false;
423                                                 if (currencyCode.length() == 3) {
424                                                         // Try to format the currency using the Java Locales system.
425                                                         try {
426                                                                 Currency currency = Currency.getInstance(currencyCode);
427                                                                 Log.info("A valid ISO 4217 currency code is being used. Overriding the numeric formatting with information from the locale.");
428                                                                 int digits = currency.getDefaultFractionDigits();
429                                                                 numFormatJava = NumberFormat.getCurrencyInstance(locale);
430                                                                 numFormatJava.setCurrency(currency);
431                                                                 numFormatJava.setMinimumFractionDigits(digits);
432                                                                 numFormatJava.setMaximumFractionDigits(digits);
433                                                         } catch (IllegalArgumentException e) {
434                                                                 Log.warn(currencyCode
435                                                                                 + " is not a valid ISO 4217 code. Manually setting currency code with this value.");
436                                                                 // The currency code is not this is not an ISO 4217 currency code.
437                                                                 // We're going to manually set the currency code and use the glom numeric formatting.
438                                                                 useGlomCurrencyCode = true;
439                                                                 numFormatJava = getJavaNumberFormat(numFormatGlom);
440                                                         }
441                                                 } else if (currencyCode.length() > 0) {
442                                                         Log.warn(currencyCode
443                                                                         + " is not a valid ISO 4217 code. Manually setting currency code with this value.");
444                                                         // The length of the currency code is > 0 and != 3; this is not an ISO 4217 currency code.
445                                                         // We're going to manually set the currency code and use the glom numeric formatting.
446                                                         useGlomCurrencyCode = true;
447                                                         numFormatJava = getJavaNumberFormat(numFormatGlom);
448                                                 } else {
449                                                         // The length of the currency code is 0; the number is not a currency.
450                                                         numFormatJava = getJavaNumberFormat(numFormatGlom);
451                                                 }
452
453                                                 // TODO: Do I need to do something with NumericFormat.get_default_precision() from libglom?
454
455                                                 double number = rs.getDouble(i + 1);
456                                                 if (number < 0) {
457                                                         if (formatting.getM_numeric_format().getM_alt_foreground_color_for_negatives())
458                                                                 // overrides the set foreground colour
459                                                                 rowArray[i].setFGColour(convertGdkColorToHtmlColour(NumericFormat
460                                                                                 .get_alternative_color_for_negatives()));
461                                                 }
462
463                                                 // Finally convert the number to text using the glom currency string if required.
464                                                 if (useGlomCurrencyCode) {
465                                                         rowArray[i].setText(currencyCode + " " + numFormatJava.format(number));
466                                                 } else {
467                                                         rowArray[i].setText(numFormatJava.format(number));
468                                                 }
469                                                 break;
470                                         case TYPE_DATE:
471                                                 Date date = rs.getDate(i + 1);
472                                                 if (date != null) {
473                                                         DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.MEDIUM, locale);
474                                                         rowArray[i].setText(dateFormat.format(date));
475                                                 } else {
476                                                         rowArray[i].setText("");
477                                                 }
478                                                 break;
479                                         case TYPE_TIME:
480                                                 Time time = rs.getTime(i + 1);
481                                                 if (time != null) {
482                                                         DateFormat timeFormat = DateFormat.getTimeInstance(DateFormat.MEDIUM, locale);
483                                                         rowArray[i].setText(timeFormat.format(time));
484                                                 } else {
485                                                         rowArray[i].setText("");
486                                                 }
487                                                 break;
488                                         case TYPE_IMAGE:
489                                                 byte[] image = rs.getBytes(i + 1);
490                                                 if (image != null) {
491                                                         // TODO implement field TYPE_IMAGE
492                                                         rowArray[i].setText("Image (FIXME)");
493                                                 } else {
494                                                         rowArray[i].setText("");
495                                                 }
496                                                 break;
497                                         case TYPE_INVALID:
498                                         default:
499                                                 Log.warn("Invalid LayoutItem Field type. Using empty string for value.");
500                                                 rowArray[i].setText("");
501                                                 break;
502                                         }
503                                 }
504
505                                 // add the row of GlomFields to the ArrayList we're going to return and update the row count
506                                 rowsList.add(rowArray);
507                                 rowCount++;
508                         }
509                 } catch (SQLException e) {
510                         Log.error("Error executing database query.", e);
511                         // TODO: somehow notify user of problem
512                 } finally {
513                         // cleanup everything that has been used
514                         try {
515                                 rs.close();
516                                 st.close();
517                                 conn.close();
518                         } catch (Exception e) {
519                                 Log.error("Error closing database resources. Subsequent database queries may not work.", e);
520                         }
521                 }
522                 return rowsList;
523         }
524
525         private NumberFormat getJavaNumberFormat(NumericFormat numFormatGlom) {
526                 NumberFormat numFormatJava = NumberFormat.getInstance(locale);
527                 if (numFormatGlom.getM_decimal_places_restricted()) {
528                         int digits = safeLongToInt(numFormatGlom.getM_decimal_places());
529                         numFormatJava.setMinimumFractionDigits(digits);
530                         numFormatJava.setMaximumFractionDigits(digits);
531                 }
532                 numFormatJava.setGroupingUsed(numFormatGlom.getM_use_thousands_separator());
533                 return numFormatJava;
534         }
535
536         /*
537          * Converts a Gdk::Color (16-bits per channel) to an HTML colour (8-bits per channel) by discarding the least
538          * significant 8-bits in each channel.
539          */
540         private String convertGdkColorToHtmlColour(String gdkColor) {
541                 if (gdkColor.length() == 13)
542                         return gdkColor.substring(0, 2) + gdkColor.substring(5, 6) + gdkColor.substring(9, 10);
543                 else if (gdkColor.length() == 7) {
544                         // FIXME will this happen in on 32-bit?
545                         Log.warn("convertGdkColorToHtmlColour(): Expected a 13 character string but received a 7 character string. Returning received string.");
546                         return gdkColor;
547                 } else {
548                         Log.error("convertGdkColorToHtmlColour(): Did not receive a 13 or 7 character string. Returning black HTML colour code.");
549                         return "#000000";
550                 }
551         }
552
553         /*
554          * This method converts a FieldFormatting.HorizontalAlignment to the equivalent ColumnInfo.HorizontalAlignment. The
555          * need for this comes from the fact that the GWT HorizontalAlignment classes can't be used with RPC and there's no
556          * easy way to use the java-libglom FieldFormatting.HorizontalAlignment enum with RPC. An enum identical to
557          * FieldFormatting.HorizontalAlignment is included in the ColumnInfo class.
558          */
559         private ColumnInfo.HorizontalAlignment getColumnInfoHorizontalAlignment(
560                         FieldFormatting.HorizontalAlignment alignment) {
561                 int value = alignment.swigValue();
562                 ColumnInfo.HorizontalAlignment[] columnInfoValues = ColumnInfo.HorizontalAlignment.class.getEnumConstants();
563                 if (value < columnInfoValues.length && value >= 0)
564                         return columnInfoValues[value];
565                 Log.error("getColumnInfoHorizontalAlignment(): Mismatch between "
566                                 + FieldFormatting.HorizontalAlignment.class.getName() + " and "
567                                 + ColumnInfo.HorizontalAlignment.class.getName() + ". Returning HORIZONTAL_ALIGNMENT_RIGHT.");
568                 return columnInfoValues[FieldFormatting.HorizontalAlignment.HORIZONTAL_ALIGNMENT_RIGHT.swigValue()];
569         }
570 }