Add new page for demo selection.
[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.FilenameFilter;
25 import java.io.IOException;
26 import java.sql.Connection;
27 import java.sql.Date;
28 import java.sql.ResultSet;
29 import java.sql.SQLException;
30 import java.sql.Statement;
31 import java.sql.Time;
32 import java.text.DateFormat;
33 import java.text.NumberFormat;
34 import java.util.ArrayList;
35 import java.util.Currency;
36 import java.util.Locale;
37 import java.util.Properties;
38
39 import org.glom.libglom.BakeryDocument.LoadFailureCodes;
40 import org.glom.libglom.Document;
41 import org.glom.libglom.Field;
42 import org.glom.libglom.FieldFormatting;
43 import org.glom.libglom.FieldVector;
44 import org.glom.libglom.Glom;
45 import org.glom.libglom.LayoutFieldVector;
46 import org.glom.libglom.LayoutGroupVector;
47 import org.glom.libglom.LayoutItem;
48 import org.glom.libglom.LayoutItemVector;
49 import org.glom.libglom.LayoutItem_Field;
50 import org.glom.libglom.NumericFormat;
51 import org.glom.libglom.SortClause;
52 import org.glom.libglom.SortFieldPair;
53 import org.glom.libglom.StringVector;
54 import org.glom.web.client.OnlineGlomService;
55 import org.glom.web.shared.ColumnInfo;
56 import org.glom.web.shared.GlomDocument;
57 import org.glom.web.shared.GlomField;
58 import org.glom.web.shared.LayoutListTable;
59
60 import com.allen_sauer.gwt.log.client.Log;
61 import com.google.gwt.user.server.rpc.RemoteServiceServlet;
62 import com.mchange.v2.c3p0.ComboPooledDataSource;
63 import com.mchange.v2.c3p0.DataSources;
64
65 @SuppressWarnings("serial")
66 public class OnlineGlomServiceImpl extends RemoteServiceServlet implements OnlineGlomService {
67         private Document document = null;
68         private ComboPooledDataSource cpds = null;
69         // TODO implement locale
70         private final Locale locale = Locale.ROOT;
71         private boolean configured = false;
72
73         /*
74          * This is called when the servlet is started or restarted.
75          */
76         public OnlineGlomServiceImpl() {
77                 Glom.libglom_init();
78         }
79
80         /*
81          * The properties file can't be loaded in the constructor because the servlet is not yet initialised and
82          * getServletContext() will return null. The work-around for this problem is to initialise the database and glom
83          * document object when makes its first request.
84          */
85         private void configureServlet() {
86                 document = new Document();
87
88                 Properties props = new Properties();
89                 String propFileName = "/WEB-INF/OnlineGlom.properties";
90                 try {
91                         props.load(getServletContext().getResourceAsStream(propFileName));
92                 } catch (IOException e) {
93                         Log.fatal("Error loading " + propFileName, e);
94                         // TODO can't continue, notify user of problem
95                 }
96
97                 File file = new File(props.getProperty("glomfile"));
98                 document.set_file_uri("file://" + file.getAbsolutePath());
99                 int error = 0;
100                 boolean retval = document.load(error);
101                 if (retval == false) {
102                         String message;
103                         if (LoadFailureCodes.LOAD_FAILURE_CODE_NOT_FOUND == LoadFailureCodes.swigToEnum(error)) {
104                                 message = "Could not find " + file.getAbsolutePath();
105                         } else {
106                                 message = "An unknown error occurred when trying to load " + file.getAbsolutePath();
107                         }
108                         Log.fatal(message);
109                         // TODO can't continue, notify user of problem
110                 }
111
112                 // load the jdbc driver
113                 cpds = new ComboPooledDataSource();
114                 try {
115                         cpds.setDriverClass("org.postgresql.Driver");
116                 } catch (PropertyVetoException e) {
117                         Log.fatal("Error loading the PostgreSQL JDBC driver. Is the PostgreSQL JDBC jar available to the servlet?",
118                                         e);
119                         // TODO can't continue, notify user of problem
120                 }
121
122                 cpds.setJdbcUrl("jdbc:postgresql://" + document.get_connection_server() + "/"
123                                 + document.get_connection_database());
124                 cpds.setUser(props.getProperty("dbusername"));
125                 cpds.setPassword(props.getProperty("dbpassword"));
126                 // TODO notify user if dbusername or dbpassword are wrong
127                 configured = true;
128         }
129
130         /*
131          * This is called when the servlet is stopped or restarted.
132          * 
133          * @see javax.servlet.GenericServlet#destroy()
134          */
135         @Override
136         public void destroy() {
137                 Glom.libglom_deinit();
138                 try {
139                         if (configured)
140                                 DataSources.destroy(cpds);
141                 } catch (SQLException e) {
142                         Log.error("Error cleaning up the ComboPooledDataSource", e);
143                 }
144         }
145
146         /*
147          * FIXME I think Swig is generating long on 64-bit machines and int on 32-bit machines - need to keep this constant
148          * http://stackoverflow.com/questions/1590831/safely-casting-long-to-int-in-java
149          */
150         private static int safeLongToInt(long l) {
151                 if (l < Integer.MIN_VALUE || l > Integer.MAX_VALUE) {
152                         throw new IllegalArgumentException(l + " cannot be cast to int without changing its value.");
153                 }
154                 return (int) l;
155         }
156
157         public GlomDocument getGlomDocument() {
158                 if (!configured)
159                         configureServlet();
160
161                 GlomDocument glomDocument = new GlomDocument();
162
163                 // get arrays of table names and titles, and find the default table index
164                 StringVector tablesVec = document.get_table_names();
165
166                 int numTables = safeLongToInt(tablesVec.size());
167                 // we don't know how many tables will be hidden so we'll use half of the number of tables for the default size
168                 // of the ArrayList
169                 ArrayList<String> tableNames = new ArrayList<String>(numTables / 2);
170                 ArrayList<String> tableTitles = new ArrayList<String>(numTables / 2);
171                 boolean foundDefaultTable = false;
172                 int visibleIndex = 0;
173                 for (int i = 0; i < numTables; i++) {
174                         String tableName = tablesVec.get(i);
175                         if (!document.get_table_is_hidden(tableName)) {
176                                 tableNames.add(tableName);
177                                 // JNI is "expensive", the comparison will only be called if we haven't already found the default table
178                                 if (!foundDefaultTable && tableName.equals(document.get_default_table())) {
179                                         glomDocument.setDefaultTableIndex(visibleIndex);
180                                         foundDefaultTable = true;
181                                 }
182                                 tableTitles.add(document.get_table_title(tableName));
183                                 visibleIndex++;
184                         }
185                 }
186
187                 // set everything we need
188                 glomDocument.setTableNames(tableNames);
189                 glomDocument.setTableTitles(tableTitles);
190                 glomDocument.setTitle(document.get_database_title());
191
192                 return glomDocument;
193         }
194
195         public LayoutListTable getLayoutListTable(String table) {
196                 if (!configured)
197                         configureServlet();
198
199                 LayoutListTable tableInfo = new LayoutListTable();
200
201                 // access the layout list
202                 LayoutGroupVector layoutListVec = document.get_data_layout_groups("list", table);
203                 ColumnInfo[] columns = null;
204                 LayoutFieldVector layoutFields = new LayoutFieldVector();
205                 int listViewLayoutGroupSize = safeLongToInt(layoutListVec.size());
206                 if (listViewLayoutGroupSize > 0) {
207                         // a layout list is defined, we can use it to for the LayoutListTable
208                         if (listViewLayoutGroupSize > 1)
209                                 Log.warn("The size of the list view layout group for table " + table
210                                                 + " is greater than 1. Attempting to use the first item for the layout list view.");
211                         LayoutItemVector layoutItemsVec = layoutListVec.get(0).get_items();
212
213                         // find the defined layout list fields
214                         int numItems = safeLongToInt(layoutItemsVec.size());
215                         columns = new ColumnInfo[numItems];
216                         for (int i = 0; i < numItems; i++) {
217                                 // TODO add support for other LayoutItems (Text, Image, Button)
218                                 LayoutItem item = layoutItemsVec.get(i);
219                                 LayoutItem_Field layoutItemField = LayoutItem_Field.cast_dynamic(item);
220                                 if (layoutItemField != null) {
221                                         layoutFields.add(layoutItemField);
222                                         columns[i] = new ColumnInfo(
223                                                         layoutItemField.get_title_or_name(),
224                                                         getColumnInfoHorizontalAlignment(layoutItemField.get_formatting_used_horizontal_alignment()),
225                                                         getColumnInfoGlomFieldType(layoutItemField.get_glom_type()));
226                                 }
227                         }
228                 } else {
229                         // no layout list is defined, use the table fields as the layout list
230                         FieldVector fieldsVec = document.get_table_fields(table);
231
232                         // find the fields to display in the layout list
233                         int numItems = safeLongToInt(fieldsVec.size());
234                         columns = new ColumnInfo[numItems];
235                         for (int i = 0; i < numItems; i++) {
236                                 Field field = fieldsVec.get(i);
237                                 LayoutItem_Field layoutItemField = new LayoutItem_Field();
238                                 layoutItemField.set_full_field_details(field);
239                                 layoutFields.add(layoutItemField);
240                                 columns[i] = new ColumnInfo(layoutItemField.get_title_or_name(),
241                                                 getColumnInfoHorizontalAlignment(layoutItemField.get_formatting_used_horizontal_alignment()),
242                                                 getColumnInfoGlomFieldType(layoutItemField.get_glom_type()));
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 the field value to a string based on the glom type. We're doing the formatting on the
407                                         // server side for now but it might be useful to move this to the client side.
408                                         switch (field.get_glom_type()) {
409                                         case TYPE_TEXT:
410                                                 String text = rs.getString(i + 1);
411                                                 rowArray[i].setText(text != null ? text : "");
412                                                 break;
413                                         case TYPE_BOOLEAN:
414                                                 rowArray[i].setBoolean(rs.getBoolean(i + 1));
415                                                 break;
416                                         case TYPE_NUMERIC:
417                                                 // Take care of the numeric formatting before converting the number to a string.
418                                                 NumericFormat numFormatGlom = formatting.getM_numeric_format();
419                                                 // There's no isCurrency() method in the glom NumericFormat class so we're assuming that the
420                                                 // number should be formatted as a currency if the currency code string is not empty.
421                                                 String currencyCode = numFormatGlom.getM_currency_symbol();
422                                                 NumberFormat numFormatJava = null;
423                                                 boolean useGlomCurrencyCode = false;
424                                                 if (currencyCode.length() == 3) {
425                                                         // Try to format the currency using the Java Locales system.
426                                                         try {
427                                                                 Currency currency = Currency.getInstance(currencyCode);
428                                                                 Log.info("A valid ISO 4217 currency code is being used. Overriding the numeric formatting with information from the locale.");
429                                                                 int digits = currency.getDefaultFractionDigits();
430                                                                 numFormatJava = NumberFormat.getCurrencyInstance(locale);
431                                                                 numFormatJava.setCurrency(currency);
432                                                                 numFormatJava.setMinimumFractionDigits(digits);
433                                                                 numFormatJava.setMaximumFractionDigits(digits);
434                                                         } catch (IllegalArgumentException e) {
435                                                                 Log.warn(currencyCode
436                                                                                 + " is not a valid ISO 4217 code. Manually setting currency code with this value.");
437                                                                 // The currency code is not this is not an ISO 4217 currency code.
438                                                                 // We're going to manually set the currency code and use the glom numeric formatting.
439                                                                 useGlomCurrencyCode = true;
440                                                                 numFormatJava = getJavaNumberFormat(numFormatGlom);
441                                                         }
442                                                 } else if (currencyCode.length() > 0) {
443                                                         Log.warn(currencyCode
444                                                                         + " is not a valid ISO 4217 code. Manually setting currency code with this value.");
445                                                         // The length of the currency code is > 0 and != 3; this is not an ISO 4217 currency code.
446                                                         // We're going to manually set the currency code and use the glom numeric formatting.
447                                                         useGlomCurrencyCode = true;
448                                                         numFormatJava = getJavaNumberFormat(numFormatGlom);
449                                                 } else {
450                                                         // The length of the currency code is 0; the number is not a currency.
451                                                         numFormatJava = getJavaNumberFormat(numFormatGlom);
452                                                 }
453
454                                                 // TODO: Do I need to do something with NumericFormat.get_default_precision() from libglom?
455
456                                                 double number = rs.getDouble(i + 1);
457                                                 if (number < 0) {
458                                                         if (formatting.getM_numeric_format().getM_alt_foreground_color_for_negatives())
459                                                                 // overrides the set foreground colour
460                                                                 rowArray[i].setFGColour(convertGdkColorToHtmlColour(NumericFormat
461                                                                                 .get_alternative_color_for_negatives()));
462                                                 }
463
464                                                 // Finally convert the number to text using the glom currency string if required.
465                                                 if (useGlomCurrencyCode) {
466                                                         rowArray[i].setText(currencyCode + " " + numFormatJava.format(number));
467                                                 } else {
468                                                         rowArray[i].setText(numFormatJava.format(number));
469                                                 }
470                                                 break;
471                                         case TYPE_DATE:
472                                                 Date date = rs.getDate(i + 1);
473                                                 if (date != null) {
474                                                         DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.MEDIUM, locale);
475                                                         rowArray[i].setText(dateFormat.format(date));
476                                                 } else {
477                                                         rowArray[i].setText("");
478                                                 }
479                                                 break;
480                                         case TYPE_TIME:
481                                                 Time time = rs.getTime(i + 1);
482                                                 if (time != null) {
483                                                         DateFormat timeFormat = DateFormat.getTimeInstance(DateFormat.MEDIUM, locale);
484                                                         rowArray[i].setText(timeFormat.format(time));
485                                                 } else {
486                                                         rowArray[i].setText("");
487                                                 }
488                                                 break;
489                                         case TYPE_IMAGE:
490                                                 byte[] image = rs.getBytes(i + 1);
491                                                 if (image != null) {
492                                                         // TODO implement field TYPE_IMAGE
493                                                         rowArray[i].setText("Image (FIXME)");
494                                                 } else {
495                                                         rowArray[i].setText("");
496                                                 }
497                                                 break;
498                                         case TYPE_INVALID:
499                                         default:
500                                                 Log.warn("Invalid LayoutItem Field type. Using empty string for value.");
501                                                 rowArray[i].setText("");
502                                                 break;
503                                         }
504                                 }
505
506                                 // add the row of GlomFields to the ArrayList we're going to return and update the row count
507                                 rowsList.add(rowArray);
508                                 rowCount++;
509                         }
510                 } catch (SQLException e) {
511                         Log.error("Error executing database query.", e);
512                         // TODO: somehow notify user of problem
513                 } finally {
514                         // cleanup everything that has been used
515                         try {
516                                 rs.close();
517                                 st.close();
518                                 conn.close();
519                         } catch (Exception e) {
520                                 Log.error("Error closing database resources. Subsequent database queries may not work.", e);
521                         }
522                 }
523                 return rowsList;
524         }
525
526         public ArrayList<String> getDemoDatabaseTitles() {
527                 String glomDemoDir = "/home/ben";
528
529                 File file = new File(glomDemoDir);
530                 if (!file.isDirectory()) {
531                         // TODO notify user of error
532                         Log.fatal(glomDemoDir + " is not a directory.");
533                         return new ArrayList<String>(0);
534                 }
535
536                 if (!file.canRead()) {
537                         // TODO notify user of error
538                         Log.fatal("Can't read the files in : " + glomDemoDir);
539                         return new ArrayList<String>(0);
540                 }
541
542                 File[] glomFiles = file.listFiles(new FilenameFilter() {
543                         @Override
544                         public boolean accept(File dir, String name) {
545                                 return name.endsWith(".glom") ? true : false;
546                         }
547                 });
548
549                 ArrayList<String> dbTitles = new ArrayList<String>();
550                 for (File glomFile : glomFiles) {
551                         Document curDoc = new Document();
552                         curDoc.set_file_uri("file://" + glomFile.getAbsolutePath());
553                         int error = 0;
554                         boolean retval = curDoc.load(error);
555                         if (retval != false) {
556                                 dbTitles.add(curDoc.get_database_title());
557                         }
558                 }
559                 return dbTitles;
560         }
561
562         private NumberFormat getJavaNumberFormat(NumericFormat numFormatGlom) {
563                 NumberFormat numFormatJava = NumberFormat.getInstance(locale);
564                 if (numFormatGlom.getM_decimal_places_restricted()) {
565                         int digits = safeLongToInt(numFormatGlom.getM_decimal_places());
566                         numFormatJava.setMinimumFractionDigits(digits);
567                         numFormatJava.setMaximumFractionDigits(digits);
568                 }
569                 numFormatJava.setGroupingUsed(numFormatGlom.getM_use_thousands_separator());
570                 return numFormatJava;
571         }
572
573         /*
574          * Converts a Gdk::Color (16-bits per channel) to an HTML colour (8-bits per channel) by discarding the least
575          * significant 8-bits in each channel.
576          */
577         private String convertGdkColorToHtmlColour(String gdkColor) {
578                 if (gdkColor.length() == 13)
579                         return gdkColor.substring(0, 3) + gdkColor.substring(5, 7) + gdkColor.substring(9, 11);
580                 else if (gdkColor.length() == 7) {
581                         // FIXME will this happen in on 32-bit?
582                         Log.warn("convertGdkColorToHtmlColour(): Expected a 13 character string but received a 7 character string. Returning received string.");
583                         return gdkColor;
584                 } else {
585                         Log.error("convertGdkColorToHtmlColour(): Did not receive a 13 or 7 character string. Returning black HTML colour code.");
586                         return "#000000";
587                 }
588         }
589
590         /*
591          * This method converts a FieldFormatting.HorizontalAlignment to the equivalent ColumnInfo.HorizontalAlignment. The
592          * need for this comes from the fact that the GWT HorizontalAlignment classes can't be used with RPC and there's no
593          * easy way to use the java-libglom FieldFormatting.HorizontalAlignment enum with RPC. An enum identical to
594          * FieldFormatting.HorizontalAlignment is included in the ColumnInfo class.
595          */
596         private ColumnInfo.HorizontalAlignment getColumnInfoHorizontalAlignment(
597                         FieldFormatting.HorizontalAlignment alignment) {
598                 switch (alignment) {
599                 case HORIZONTAL_ALIGNMENT_AUTO:
600                         return ColumnInfo.HorizontalAlignment.HORIZONTAL_ALIGNMENT_AUTO;
601                 case HORIZONTAL_ALIGNMENT_LEFT:
602                         return ColumnInfo.HorizontalAlignment.HORIZONTAL_ALIGNMENT_LEFT;
603                 case HORIZONTAL_ALIGNMENT_RIGHT:
604                         return ColumnInfo.HorizontalAlignment.HORIZONTAL_ALIGNMENT_RIGHT;
605                 default:
606                         Log.error("getColumnInfoGlomFieldType(): Recieved an alignment that I don't know about: "
607                                         + FieldFormatting.HorizontalAlignment.class.getName() + "." + alignment.toString() + ". Returning "
608                                         + ColumnInfo.HorizontalAlignment.HORIZONTAL_ALIGNMENT_RIGHT.toString() + ".");
609                         return ColumnInfo.HorizontalAlignment.HORIZONTAL_ALIGNMENT_RIGHT;
610                 }
611         }
612
613         /*
614          * This method converts a Field.glom_field_type to the equivalent ColumnInfo.FieldType. The need for this comes from
615          * the fact that the GWT FieldType classes can't be used with RPC and there's no easy way to use the java-libglom
616          * Field.glom_field_type enum with RPC. An enum identical to FieldFormatting.glom_field_type is included in the
617          * ColumnInfo class.
618          */
619         private ColumnInfo.GlomFieldType getColumnInfoGlomFieldType(Field.glom_field_type type) {
620                 switch (type) {
621                 case TYPE_BOOLEAN:
622                         return ColumnInfo.GlomFieldType.TYPE_BOOLEAN;
623                 case TYPE_DATE:
624                         return ColumnInfo.GlomFieldType.TYPE_DATE;
625                 case TYPE_IMAGE:
626                         return ColumnInfo.GlomFieldType.TYPE_IMAGE;
627                 case TYPE_NUMERIC:
628                         return ColumnInfo.GlomFieldType.TYPE_NUMERIC;
629                 case TYPE_TEXT:
630                         return ColumnInfo.GlomFieldType.TYPE_TEXT;
631                 case TYPE_TIME:
632                         return ColumnInfo.GlomFieldType.TYPE_TIME;
633                 case TYPE_INVALID:
634                         Log.info("getColumnInfoGlomFieldType(): Returning TYPE_INVALID.");
635                         return ColumnInfo.GlomFieldType.TYPE_INVALID;
636                 default:
637                         Log.error("getColumnInfoGlomFieldType(): Recieved a type that I don't know about: "
638                                         + Field.glom_field_type.class.getName() + "." + type.toString() + ". Returning "
639                                         + ColumnInfo.GlomFieldType.TYPE_INVALID.toString() + ".");
640                         return ColumnInfo.GlomFieldType.TYPE_INVALID;
641                 }
642         }
643
644 }