path: root/creationpanel.py

# -*- coding: utf-8 -*-
# Copyright (c) 2010, Kirk Winans
# Code originally based on Simon Schampijer's code for the Memorize
# Activity


# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
# Boston, MA 02111-1307, USA.
import gtk
from os import environ
from os.path import join, basename
import hippo

import shutil
import tempfile
from gettext import gettext as _
import logging
from gobject import SIGNAL_RUN_FIRST, TYPE_PYOBJECT
from sugar.graphics import style
from sugar.graphics.toolbutton import ToolButton
from sugar.graphics.icon import Icon
from sugar.graphics.palette import Palette
from port.widgets import ToggleToolButton
from port.widgets import CanvasRoundBox, ToolComboBox
#from port import chooser

from sugar.datastore import datastore
import xml.etree.ElementTree
from datetime import date
import time
_logger = logging.getLogger("test-activity")

_DAY = 60 * 60 * 24

#
# Creation Panel for Flashcard Activity
#
class CreationPanel(gtk.VBox):
    
    def __init__(self, deckfile, front_text, back_text, catagory_text, editing):
        gtk.VBox.__init__(self)

        self.main_box = gtk.VBox()
        self.side_entries_box = gtk.VBox()
        self.catagory_box = gtk.HBox()

        # Text Entries
        self.s1e_label = gtk.Label(_('Front:'))
        self.side_1_entry = gtk.Entry()
        self.s2e_label = gtk.Label(_('Back:'))
        self.side_2_entry = gtk.Entry()
        self.ce_label = gtk.Label(_('Category:'))
        self.catagory_entry = gtk.Entry()

        self.side_1_entry.set_text(front_text)
        self.side_2_entry.set_text(back_text)
        self.catagory_entry.set_text(catagory_text)

        self.side_entries_box.pack_start(self.s1e_label, True, True)
        self.side_entries_box.pack_start(self.side_1_entry, True, True)
        self.side_entries_box.pack_start(self.s2e_label, True, True)
        self.side_entries_box.pack_start(self.side_2_entry, True, True)
        self.main_box.pack_start(self.side_entries_box, True, True)
        self.catagory_box.pack_start(self.ce_label, True, True)
        self.catagory_box.pack_start(self.catagory_entry, True, True)
        self.main_box.pack_start(self.catagory_box, True, True)


        self.add(self.main_box)
        

        self.s1e_label.show()
        self.side_1_entry.show()
        self.s2e_label.show()
        self.side_2_entry.show()
        self.side_entries_box.show()
        self.ce_label.show()
        self.catagory_entry.show()
        self.catagory_box.show()
        self.main_box.show()

        
        self.button_bar = gtk.HButtonBox()
        self.button_bar.props.border_width = 10

        if editing:
            # Save Changes to card button
            _save_changes = ToolButton(tooltip=_('Save Changes'))
            _save_changes.connect('clicked', self._save_changes_cb)
            _save_changes.set_icon_widget(
                 self.make_label('pair-update', ' ' + _('Update')))
            self.button_bar.pack_start(_save_changes, False, False)
            _save_changes.show()

            # Delete Card button
            _deletebutton = ToolButton(tooltip=_('Delete'))
            _deletebutton.connect('clicked', self._delete_card_cb)
            _deletebutton.set_icon_widget(
                 self.make_label('remove', ' ' + _('Delete')))
            self.button_bar.pack_start(_deletebutton, True, True, 25)
            _deletebutton.show()

        else:
            # Add Card button
            _addbutton = ToolButton(tooltip=_('Add'))
            _addbutton.connect('clicked', self._save_card_cb)
            _addbutton.set_icon_widget(
                self.make_label('add', ' ' + _('Add')))
            self.button_bar.pack_start(_addbutton, False, False)
            _addbutton.show()

        self.pack_start(self.button_bar, False, False)
        self.button_bar.show()

        self.deckfile = deckfile

        self.decktree = xml.etree.ElementTree.parse(self.deckfile)

        self.deck = self.decktree.getroot()

        self.front_text = front_text

    # Add button callback, saves card if it has a front, back, and category
    def _save_card_cb(self, button):
        if (self.card_complete()):
            self._save_card()
            self.clear_entry_text()

    # Returns if the card is complete with a front, back, and category
    def card_complete(self):
        side1complete = self.side_1_entry.get_text() != ""
        side2complete = self.side_2_entry.get_text() != ""
        catagorycomplete = self.catagory_entry.get_text() != ""

        return side1complete and side2complete and catagorycomplete

    # Save Changes callback
    def _save_changes_cb(self, button):
        self._save_changes()
        
    # Delete Card callback
    def _delete_card_cb(self, button):
        self.delete_card()

    # Saves the new card, creates a new card element and addes it to the
    # deck, then it is written automatically into the xml file
    def _save_card(self):

        new_card = xml.etree.ElementTree.Element("card")

        n_c_front = xml.etree.ElementTree.Element("front")

        n_c_back = xml.etree.ElementTree.Element("back")

        n_c_last = xml.etree.ElementTree.Element("last_reviewed")

        n_c_stage = xml.etree.ElementTree.Element("stage")

        n_c_catagory = xml.etree.ElementTree.Element("catagory")

        n_c_front.text = self.side_1_entry.get_text()

        n_c_back.text = self.side_2_entry.get_text()

        n_c_last.text = str(time.time()-_DAY)

        n_c_stage.text = "0"

        n_c_catagory.text = self.catagory_entry.get_text()


        new_card.append(n_c_front)

        new_card.append(n_c_back)

        new_card.append(n_c_last)

        new_card.append(n_c_stage)

        new_card.append(n_c_catagory)



        self.deck.append(new_card)

        self.decktree.write(self.deckfile)


    # # Returns the appropriate deck based on the subject
    # def get_deck(self, subject_string):
    #     subject_filename = subject_string + ".xml"
    #     for deck in self.decklist:
    #         if deck.text == subject_string:
    #             return subject_filename


    #     self.add_to_deck_list(subject_string)
    #     self.create_xml_file(subject_filename)
    #     return subject_filename

    # # Adds new deck to the deck list xml file
    # def add_to_deck_list(self, deckname):
    #     new_deck = xml.etree.ElementTree.Element("deck")
    #     new_deck.text = deckname
    #     self.decklist.append(new_deck)
    #     self.decktree.write(self.decklistfile)
        

    # # Creates a new xml file with the name of the new subject
    # def create_xml_file(self, filename):
    #     new_deck = xml.etree.ElementTree.Element("deck")
    #     new_tree = xml.etree.ElementTree.ElementTree(new_deck)
    #     new_tree.write(filename)



    # Saves changes to the edited card, and writes the change to the xml file
    def _save_changes(self):

        edited_card = self.get_edited_card()


        edited_card_front = edited_card.find("front")
        edited_card_back = edited_card.find("back")
        edited_card_catagory = edited_card.find("catagory")

        edited_card_front.text = self.side_1_entry.get_text()
        edited_card_back.text = self.side_2_entry.get_text()
        edited_card_catagory.text = self.catagory_entry.get_text()

        self.tree.write(self.testfile)

    # Deletes the card from the file, removes the card from the deck,
    # then writes the changed deck to the xml file
    def delete_card(self):
        edited_card = self.get_edited_card()
        self.deck.remove(edited_card)
        self.tree.write(self.testfile)


        self.clear_entry_text()

    # Returns the card to edit
    def get_edited_card(self):

        cards = self.deck.findall("card")
        length = str(len(cards))

        for c in cards:

            front = c.find("front")
            if front.text == self.front_text:
                return c

    # Clears the text in the text entries so that new cards can be made
    def clear_entry_text(self):
       self.side_1_entry.set_text("")
       self.side_2_entry.set_text("")
       self.catagory_entry.set_text("") 
        
    # Gets the icon for button and makes the label
    # Written by Simon Schampijer
    def make_label(self, icon_name, label):
        label_box = gtk.HBox()
        icon = Icon(
                icon_name=icon_name,
                icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR)
        label_box.pack_start(icon, False)
        label = gtk.Label(label)
        label.modify_fg(gtk.STATE_NORMAL,
                style.COLOR_TOOLBAR_GREY.get_gdk_color())
        label_box.pack_start(label)
        label_box.show_all()
        return label_box