current status

3 files changed, 123 insertions, 249 deletions

diff --git a/odftops-filter/odftops2 b/odftops-filter/odftops2
deleted file mode 100644
index d142bf8..0000000
--- a/odftops-filter/odftops2
+++ /dev/null
@@ -1,67 +0,0 @@
-#!/bin/bash
-# CUPS filter to process ODT files using abiword
-
-
-
-# $6 happens to be the path to file passed as argument 
-
-fn="$6"
-
-#for our subshell convenience
-
-sandbox1="${TMPDIR1:-/tmp}/tempcups.$$"
-(umask 077 && mkdir "$sandbox1") || exit 1
-
-
-# we are creating a dummy folder, which can take different file types.
-
-sandbox="${TMPDIR:-/tmp}/cups-odftops.$$"
-(umask 077 && mkdir "$sandbox") || exit 1
-
-
-#The condition which checks whether our abiword is 2.6.6+ or 2.6.6-
-
-$(abiword --to="$sandbox1/temp123.doc" "$fn")
-
-if [ "$?" -ne 0 ];
-
-then
-
-#our dummy file
-
-fn1="$sandbox/temp123.odt"
-
-cp "$fn" "$fn1"
-
-# Call abiword quietly, securely 
-
-abiword --to="ps" "$fn1"
-
-fn2="`echo "$fn1" | sed -e 's/odt$/ps/' `"
-
-else
-
-#check if our version doesn't require an intermediate conversion, 
-#if it does, do it
-
-$(abiword --to="$sandbox1/temp123.ps" "$fn")
-
-if [ "$?" -ne 0 ];
-
-then
-
-abiword --to="$sandbox/temp123.ps" "$sandbox1/temp123.doc"
-
-else
-
-abiword --to="$sandbox/temp123.ps" "$fn"
-fn2="$sandbox/temp123.ps"
-fi
-
-fi
-
-cat "$fn2"
-
-#remove the sandbox folder, for debugging purposes check by commenting the following line and see what is in the /tmp/ folder
-rm -rf $sandbox
-rm -rf $sandbox1
diff --git a/printactivity.py b/printactivity.py
index e5b23e6..6a598bd 100644
--- a/printactivity.py
+++ b/printactivity.py
@@ -34,13 +34,15 @@ from sugar import mime
 from sugar.datastore import datastore
 from sugar.graphics.objectchooser import ObjectChooser
 
-from printtoolbar import EditToolbar, ReadToolbar, ViewToolbar
+from printscript import serverConnection
+from printtoolbar import PrintToolbar,DocumentToolbar, ReadToolbar, ViewToolbar
 
 _HARDWARE_MANAGER_INTERFACE = 'org.laptop.HardwareManager'
 _HARDWARE_MANAGER_SERVICE = 'org.laptop.HardwareManager'
 _HARDWARE_MANAGER_OBJECT_PATH = '/org/laptop/HardwareManager'
 
 _TOOLBAR_READ = 2
+CUPS_PDF = "Cups-PDF"
 
 _logger = logging.getLogger('read-activity')
 
@@ -108,24 +110,20 @@ class ReadActivity(activity.Activity):
         self.connect('key-press-event', self._key_press_event_cb)
         self.connect('key-release-event', self._key_release_event_cb)
 
-        _logger.debug('Starting Read...')
+        _logger.debug('Starting Print...')
         
         self._view = evince.View()
         self._view.set_screen_dpi(_get_screen_dpi())
-        self._view.connect('notify::has-selection',
-                           self._view_notify_has_selection_cb)
 
         toolbox = activity.ActivityToolbox(self)
 
-        self._edit_toolbar = EditToolbar(self._view)
-        self._edit_toolbar.undo.props.visible = False
-        self._edit_toolbar.redo.props.visible = False
-        self._edit_toolbar.separator.props.visible = False
-        self._edit_toolbar.copy.set_sensitive(False)
-        self._edit_toolbar.copy.connect('clicked', self._edit_toolbar_copy_cb)
-        self._edit_toolbar.paste.props.visible = False
-        toolbox.add_toolbar(_('Edit'), self._edit_toolbar)
-        self._edit_toolbar.show()
+        self._print_toolbar = PrintToolbar(self._view)
+        toolbox.add_toolbar(_('Print'), self._print_toolbar)
+        self._print_toolbar.show()
+
+        self._document_toolbar = DocumentToolbar(self._view)
+        toolbox.add_toolbar(_('Documents'), self._document_toolbar)
+        self._document_toolbar.show()
 
         self._read_toolbar = ReadToolbar(self._view)
         toolbox.add_toolbar(_('Read'), self._read_toolbar)
@@ -274,8 +272,10 @@ class ReadActivity(activity.Activity):
         return False
 
     def read_file(self, file_path):
+        if file_path[-3:] == "odt":
+           file_path = self._open_pdf (file_path)
         """Load a file from the datastore on activity start."""
-        _logger.debug('ReadActivity.read_file: %s', file_path)
+        _logger.debug('PrintActivity.read_file: %s', file_path)
         tempfile = os.path.join(self.get_activity_root(), 'instance',
                                 'tmp%i' % time.time())
         os.link(file_path, tempfile)
@@ -286,53 +286,49 @@ class ReadActivity(activity.Activity):
         gobject.timeout_add(1000, self.__view_toolbar_needs_update_size_cb,
             None)
 
-    def write_file(self, file_path):
-        """Write into datastore for Keep.
-        
-        The document is saved by hardlinking from the temporary file we
-        keep around instead of "saving".
 
-        The metadata is updated, including current page, view settings,
-        search text.
+    def _open_pdf(self, file_path):
+        self._connection = serverConnection () 
+        self._connection._printFile (CUPS_PDF, file_path)
+        sleep(10)
+        f = open('/etc/cups/cups-pdf.conf', 'r')
+        for line in f:
+            if line[0:2] == 'Out':
+                self._location = line[3:]
+                break
+        f.close()
+        title = os.path.split(file_path)[1].rsplit('.',1)[0]
+        fileObject = datastore.create()
+        act_meta = self.metadata
+        fileObject.metadata['title'] = title
+        fileObject.metadata['title_set_by_user'] = act_meta['title_set_by_user']
+        fileObject.metadata['mime_type'] = 'application/pdf'
+
+        fileObject.metadata['icon-color'] = act_meta['icon-color']
+        fileObject.metadata['activity'] = act_meta['activity']
+        fileObject.metadata['keep'] = act_meta['keep']
+
+# TODO: Activity class should provide support for preview, see #5119
+#        self._activity.take_screenshot()
+#        if self._activity._preview:
+#            preview = self._activity._get_preview()
+#            fileObject.metadata['preview'] = dbus.ByteArray(preview)
+
+        fileObject.metadata['share-scope'] = act_meta['share-scope']
+
+        # write out the document contents in the requested format
+        filepath = fileObject.file_path = os.path.join(self._location + title + '.pdf', 'instance', '%i' % time.time())
         
-        """
-        if self._tempfile is None:
-            # Workaround for closing Read with no document loaded
-            raise NotImplementedError
+        # store the journal item
+        datastore.write(fileObject, transfer_ownership=True)
+        fileObject.destroy()
+        del fileObject
 
-        try:
-            self.metadata['Read_current_page'] = \
-                        str(self._document.get_page_cache().get_current_page())
-
-            self.metadata['Read_zoom'] = str(self._view.props.zoom)
-
-            if self._view.props.sizing_mode == evince.SIZING_BEST_FIT:
-                self.metadata['Read_sizing_mode'] = "best-fit"
-            elif self._view.props.sizing_mode == evince.SIZING_FREE:
-                self.metadata['Read_sizing_mode'] = "free"
-            elif self._view.props.sizing_mode == evince.SIZING_FIT_WIDTH:
-                self.metadata['Read_sizing_mode'] = "fit-width"
-            else:
-                _logger.error("Don't know how to save sizing_mode state '%s'" %
-                              self._view.props.sizing_mode)
-                self.metadata['Read_sizing_mode'] = "fit-width"
-
-            self.metadata['Read_search'] = \
-                    self._edit_toolbar._search_entry.props.text
-
-        except Exception, e:
-            _logger.error('write_file(): %s', e)
-
-        self.metadata['Read_search'] = \
-                self._edit_toolbar._search_entry.props.text
+        return filepath
+        
 
-        os.link(self._tempfile, file_path)
 
-        if self._close_requested:
-            _logger.debug("Removing temp file %s because we will close",
-                          self._tempfile)
-            os.unlink(self._tempfile)
-            self._tempfile = None
+       
 
     def can_close(self):
         """Prepare to cleanup on closing.
@@ -451,7 +447,6 @@ class ReadActivity(activity.Activity):
         self._document = evince.factory_get_document(filepath)
         self._want_document = False
         self._view.set_document(self._document)
-        self._edit_toolbar.set_document(self._document)
         self._read_toolbar.set_document(self._document)
 
         if not self.metadata['title_set_by_user'] == '1':
@@ -483,9 +478,6 @@ class ReadActivity(activity.Activity):
 
         self._view_toolbar._update_zoom_buttons()
 
-        self._edit_toolbar._search_entry.props.text = \
-                                self.metadata.get('Read_search', '')
-
         # We've got the document, so if we're a shared activity, offer it
         try:
             if self.get_shared():
@@ -556,11 +548,7 @@ class ReadActivity(activity.Activity):
         self.watch_for_tubes()
         self._share_document()
 
-    def _view_notify_has_selection_cb(self, view, pspec):
-        self._edit_toolbar.copy.set_sensitive(self._view.props.has_selection)
 
-    def _edit_toolbar_copy_cb(self, button):
-        self._view.copy()
 
     def _key_press_event_cb(self, widget, event):
         keyname = gtk.gdk.keyval_name(event.keyval)
diff --git a/printtoolbar.py b/printtoolbar.py
index 5c812c9..69edd14 100644
--- a/printtoolbar.py
+++ b/printtoolbar.py
@@ -27,139 +27,92 @@ from sugar.graphics.toolbutton import ToolButton
 from sugar.graphics.menuitem import MenuItem
 from sugar.graphics import iconentry
 from sugar.activity import activity
+from printscript import serverConnection
 
-class EditToolbar(activity.EditToolbar):
-    __gtype_name__ = 'EditToolbar'
 
-    def __init__(self, evince_view):
-        activity.EditToolbar.__init__(self)
-
-        self._evince_view = evince_view
-        self._evince_view.find_set_highlight_search(True)
 
-        self._document = None
-        self._find_job = None
-
-        separator = gtk.SeparatorToolItem()
-        separator.set_draw(False)
-        separator.set_expand(True)
-        self.insert(separator, -1)
-        separator.show()
-
-        search_item = gtk.ToolItem()
-
-        self._search_entry = iconentry.IconEntry()
-        self._search_entry.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
-                                                'system-search')
-        self._search_entry.add_clear_button()
-        self._search_entry.connect('activate', self._search_entry_activate_cb)
-        self._search_entry.connect('changed', self._search_entry_changed_cb)
-        self._search_entry_changed = True
-
-        width = int(gtk.gdk.screen_width() / 3)
-        self._search_entry.set_size_request(width, -1)
-
-        search_item.add(self._search_entry)
-        self._search_entry.show()
-
-        self.insert(search_item, -1)
-        search_item.show()
-
-        self._prev = ToolButton('go-previous-paired')
-        self._prev.set_tooltip(_('Previous'))
-        self._prev.props.sensitive = False
-        self._prev.connect('clicked', self._find_prev_cb)
-        self.insert(self._prev, -1)
-        self._prev.show()
-
-        self._next = ToolButton('go-next-paired')
-        self._next.set_tooltip(_('Next'))
-        self._next.props.sensitive = False
-        self._next.connect('clicked', self._find_next_cb)
-        self.insert(self._next, -1)
-        self._next.show()
 
-    def set_document(self, document):
-        self._document = document
+class PrintToolbar(gtk.Toolbar):
+    __gtype_name__= 'PrintToolbar'
 
-    def _clear_find_job(self):
-        if self._find_job is None:
-            return
-        if not self._find_job.is_finished():
-            self._find_job.cancel()
-        self._find_job.disconnect(self._find_updated_handler)
-        self._find_job = None
-
-    def _search_find_first(self):
-        self._clear_find_job()
-        text = self._search_entry.props.text
-        if text != "":
-            self._find_job = evince.JobFind(document=self._document, start_page=0, n_pages=self._document.get_n_pages(), text=text, case_sensitive=False)
-            self._find_updated_handler = self._find_job.connect('updated', self._find_updated_cb)
-            evince.job_scheduler_push_job(self._find_job, evince.JOB_PRIORITY_NONE)
-        else:
-            # FIXME: highlight nothing
-            pass
 
-        self._search_entry_changed = False
-        self._update_find_buttons()
+    def __init__(self, evince_view):
+        gtk.Toolbar.__init__(self)
 
-    def _search_find_next(self):
-        self._evince_view.find_next()
+        self._evince_view = evince_view
+        self._document = None
+        
+        
+        self._pdf = ToolButton('go-previous-paired')
+        self._pdf.set_tooltip(_('save-PDF'))
+        self._pdf.props.sensitive = False
+        self._pdf.connect('clicked', self._save_as_pdf)
+        self.insert(self._pdf, -1)
+        self._pdf.show()
+
+        self._print = ToolButton("print")
+        self._print.set_tooltip(_('Print'))
+        self._print.props.sensitive = False
+        self._print.connect('clicked', self._print_to_printer)
+        self.insert(self._print, -1)
+        self._print.show()
+
+    def _save_as_pdf(self, button):
+        self._connection = ServerConnection()
+    def _print_to_printer(self, button):
+        self._connection = ServerConnection()
+        
 
-    def _search_find_last(self):
-        # FIXME: does Evince support find last?
-        return
+class DocumentToolbar(gtk.Toolbar):
+    __gtype_name__= 'DocumentToolbar'
 
-    def _search_find_prev(self):
-        self._evince_view.find_previous()
 
-    def _search_entry_activate_cb(self, entry):
-        if self._search_entry_changed:
-            self._search_find_first()
-        else:
-            self._search_find_next()
+    def __init__(self, evince_view):
+        gtk.Toolbar.__init__(self)
 
-    def _search_entry_changed_cb(self, entry):
-        self._search_entry_changed = True
-        self._update_find_buttons()
+        self._evince_view = evince_view
+        self._document = None
+        
+        
+        self._open = ToolButton()
+        self._open.set_tooltip(_('Open'))
+        self._open.props.sensitive = True
+        self._open.connect('clicked', self._show_journal_object_picker)
+        self.insert(self._open, -1)
+        self._open.show()
 
-# Automatically start search, maybe after timeout?
-#        self._search_find_first()
+        self._close = ToolButton()
+        self._close.set_tooltip(_('Close'))
+        self._close.props.sensitive = False
+        self._close.connect('clicked', self._close_a_doc)
+        self.insert(self._close, -1)
+        self._close.show()
 
-    def _find_changed_cb(self, page, spec):
-        self._update_find_buttons()
 
-    def _find_updated_cb(self, job, page):
-        self._evince_view.find_changed(job, page)
 
-    def _find_prev_cb(self, button):
-        if self._search_entry_changed:
-            self._search_find_last()
-        else:
-            self._search_find_prev()
-    
-    def _find_next_cb(self, button):
-        if self._search_entry_changed:
-            self._search_find_first()
-        else:
-            self._search_find_next()
-
-    def _update_find_buttons(self):
-        if self._search_entry_changed:
-            if self._search_entry.props.text != "":
-                self._prev.props.sensitive = False
-#                self._prev.set_tooltip(_('Find last'))
-                self._next.props.sensitive = True
-                self._next.set_tooltip(_('Find first'))
-            else:
-                self._prev.props.sensitive = False
-                self._next.props.sensitive = False
-        else:
-            self._prev.props.sensitive = True
-            self._prev.set_tooltip(_('Find previous'))
-            self._next.props.sensitive = True
-            self._next.set_tooltip(_('Find next'))
+    def _close_a_doc(self, button):
+        print 'hello!'
+        
+    def _show_journal_object_picker(self):
+        """Show the journal object picker to load a document.
+
+        This is for if Read is launched without a document.
+        """
+        chooser = ObjectChooser(_('Choose document'), self, 
+                                gtk.DIALOG_MODAL | 
+                                gtk.DIALOG_DESTROY_WITH_PARENT,
+                                what_filter=mime.GENERIC_TYPE_TEXT)
+        try:
+            result = chooser.run()
+            if result == gtk.RESPONSE_ACCEPT:
+                logging.debug('ObjectChooser: %r' % 
+                              chooser.get_selected_object())
+                jobject = chooser.get_selected_object()
+                if jobject and jobject.file_path:
+                    self.read_file(jobject.file_path)
+        finally:
+            chooser.destroy()
+            del chooser
 
 class ReadToolbar(gtk.Toolbar):
     __gtype_name__ = 'ReadToolbar'