示例#1
0
 Notebook::Ptr NotebookManager::prompt_create_new_notebook(Gtk::Window *parent,
                                                           const Note::List & notesToAdd)
 {
   // Prompt the user for the name of a new notebook
   CreateNotebookDialog dialog(parent,
                               (GtkDialogFlags)(GTK_DIALOG_MODAL
                                                | GTK_DIALOG_DESTROY_WITH_PARENT));
   
   
   int response = dialog.run ();
   std::string notebookName = dialog.get_notebook_name();
   if (response != Gtk::RESPONSE_OK)
     return Notebook::Ptr();
   
   Notebook::Ptr notebook = obj().get_or_create_notebook (notebookName);
   if (!notebook) {
     DBG_OUT ("Could not create notebook: %s", notebookName.c_str());
   } 
   else {
     DBG_OUT ("Created the notebook: %s (%s)", notebook->get_name().c_str(),
              notebook->get_normalized_name().c_str());
     
     if (!notesToAdd.empty()) {
       // Move all the specified notesToAdd into the new notebook
       for(Note::List::const_iterator iter = notesToAdd.begin();
           iter != notesToAdd.end(); ++iter) {
         obj().move_note_to_notebook (*iter, notebook);
       }
     }
   }
   
   return notebook;
 }
示例#2
0
    /// <summary>
    /// Place the specified note into the specified notebook.  If the
    /// note already belongs to a notebook, it will be removed from that
    /// notebook first.
    /// </summary>
    /// <param name="note">
    /// A <see cref="Note"/>
    /// </param>
    /// <param name="notebook">
    /// A <see cref="Notebook"/>.  If Notebook is null, the note will
    /// be removed from its current notebook.
    /// </param>
    /// <returns>True if the note was successfully moved.</returns>
    bool NotebookManager::move_note_to_notebook (const Note::Ptr & note, 
                                                 const Notebook::Ptr & notebook)
    {
      if (!note) {
        return false;
      }

      // NOTE: In the future we may want to allow notes
      // to exist in multiple notebooks.  For now, to
      // alleviate the confusion, only allow a note to
      // exist in one notebook at a time.

      Notebook::Ptr currentNotebook = get_notebook_from_note (note);
      if (currentNotebook == notebook)
        return true; // It's already there.

      if(currentNotebook) {
        note->remove_tag (currentNotebook->get_tag());
        m_note_removed_from_notebook(*note, currentNotebook);
      }

      // Only attempt to add the notebook tag when this
      // menu item is not the "No notebook" menu item.
      if(notebook) {
        note->add_tag(notebook->get_tag());
        m_note_added_to_notebook(*note, notebook);
      }

      return true;
    }
示例#3
0
    void NotebookManager::delete_notebook(const Notebook::Ptr & notebook)
    {
      if (!notebook)
        throw sharp::Exception ("NotebookManager::delete_notebook () called with a null argument.");
      std::string normalized_name = notebook->get_normalized_name();
      std::map<std::string, Gtk::TreeIter>::iterator map_iter 
        = m_notebookMap.find (normalized_name);
      if (map_iter == m_notebookMap.end())
        return;
      
//      lock (locker) {
        map_iter = m_notebookMap.find (normalized_name);
        if (map_iter == m_notebookMap.end()) {
          return;
        }
        
        Gtk::TreeIter iter = map_iter->second;;
        m_notebooks->erase (iter);
        
        m_notebookMap.erase (map_iter);
        
        // Remove the notebook tag from every note that's in the notebook
        std::list<Note *> notes;
        notebook->get_tag()->get_notes(notes);
        for(std::list<Note *>::const_iterator note_iter = notes.begin();
            note_iter != notes.end(); ++note_iter) {
          Note * note = *note_iter;
          note->remove_tag (notebook->get_tag());
          m_note_removed_from_notebook (*note, notebook);
        }
//      }
    }
示例#4
0
 void NotebookNoteAddin::update_notebook_button_label(const Notebook::Ptr & notebook)
 {
   std::string labelText = (notebook ? notebook->get_name() : _("Notebook"));
   
   m_label_widget->set_text(labelText);
   m_toolButton->show_all();
 }
示例#5
0
    /// <summary>
    /// Prompt the user and delete the notebok (if they say so).
    /// </summary>
    /// <param name="parent">
    /// A <see cref="Gtk.Window"/>
    /// </param>
    /// <param name="notebook">
    /// A <see cref="Notebook"/>
    /// </param>
    void NotebookManager::prompt_delete_notebook(Gtk::Window * parent, 
                                                 const Notebook::Ptr & notebook)
    {
      // Confirmation Dialog
      utils::HIGMessageDialog dialog(parent,
                                     GTK_DIALOG_MODAL,
                                     Gtk::MESSAGE_QUESTION,
                                     Gtk::BUTTONS_YES_NO,
                                     _("Really delete this notebook?"),
                                     _("The notes that belong to this notebook will not be "
                                       "deleted, but they will no longer be associated with "
                                       "this notebook.  This action cannot be undone."));
      dialog.set_default_response(Gtk::RESPONSE_NO);
      int response = dialog.run ();
      if (response != Gtk::RESPONSE_YES) {
        return;
      }

      // Grab the template note before removing all the notebook tags
      Note::Ptr templateNote = notebook->get_template_note ();
      
      obj().delete_notebook (notebook);

      // Delete the template note
      if (templateNote) {
        obj().note_manager().delete_note(templateNote);
      }
    }
示例#6
0
 NotebookNewNoteMenuItem::NotebookNewNoteMenuItem(const Notebook::Ptr & notebook)
   // TRANSLATORS: %1%: boost format placeholder for the notebook name
   : Gtk::ImageMenuItem(str(boost::format(_("New \"%1%\" Note")) % notebook->get_name()))
   , m_notebook(notebook)
 {
   set_image(*manage(new Gtk::Image(IconManager::obj().get_icon(IconManager::NOTE_NEW, 16))));
   signal_activate().connect(sigc::mem_fun(*this, &NotebookNewNoteMenuItem::on_activated));
 }
示例#7
0
    Notebook::Ptr NotebookManager::get_or_create_notebook(const std::string & notebookName)
    {
      if (notebookName.empty())
        throw sharp::Exception ("NotebookManager.GetNotebook () called with a null name.");
      
      Notebook::Ptr notebook = get_notebook (notebookName);
      if (notebook) {
        return notebook;
      }
      
      Gtk::TreeIter iter;
//      lock (locker) {
        notebook = get_notebook (notebookName);
        if (notebook)
          return notebook;
        
        try {
          m_adding_notebook = true;
          notebook = Notebook::Ptr(new Notebook (notebookName));
        } 
        catch(...)
        {
          // set flag to fast and rethrow
          m_adding_notebook = false;
          throw;
        }
        m_adding_notebook = false;
        iter = m_notebooks->append ();
        iter->set_value(0, notebook);
        m_notebookMap [notebook->get_normalized_name()] = iter;
        
        // Create the template note so the system tag
        // that represents the notebook actually gets
        // saved to a note (and persisted after Tomboy
        // is shut down).
        Note::Ptr templateNote = notebook->get_template_note ();
        
        // Make sure the template note has the notebook tag.
        // Since it's possible for the template note to already
        // exist, we need to make sure it gets tagged.
        templateNote->add_tag (notebook->get_tag());
        m_note_added_to_notebook (*templateNote, notebook);
//      }

      return notebook;
    }
示例#8
0
    void NotebooksTreeView::on_drag_data_received( const Glib::RefPtr<Gdk::DragContext> & context,
                                                   int x, int y,
                                                   const Gtk::SelectionData & selectionData,
                                                   guint , guint time_)
    {
      utils::UriList uriList(selectionData);
      if (uriList.size() == 0) {
        context->drag_finish (false, false, time_);
        return;
      }
      
      Gtk::TreePath treepath;
      Gtk::TreeViewDropPosition pos;
      if (get_dest_row_at_pos (x, y, treepath, pos) == false) {
        context->drag_finish (false, false, time_);
        return;
      }
      
      Gtk::TreeIter iter = get_model()->get_iter(treepath);
      if (!iter) {
        context->drag_finish (false, false, time_);
        return;
      }
      
      Notebook::Ptr destNotebook;
      iter->get_value(0, destNotebook);
      if(std::dynamic_pointer_cast<AllNotesNotebook>(destNotebook)) {
        context->drag_finish (false, false, time_);
        return;
      }

      for(utils::UriList::const_iterator uri_iter = uriList.begin();
          uri_iter != uriList.end(); ++uri_iter) {
        const sharp::Uri & uri(*uri_iter);
        NoteBase::Ptr note = m_note_manager.find_by_uri(uri.to_string());
        if (!note)
          continue;

        DBG_OUT ("Dropped into notebook: %s", note->get_title().c_str());

        destNotebook->add_note(std::static_pointer_cast<Note>(note));
      }

      context->drag_finish (true, false, time_);
    }