Changeset 27da386750c112ed04942bbc385964b4332bb128

Timestamp:

01/06/07 23:57:10 (6 years ago)

Author:

Philipp Kern <phil@…>

Parents:

c2b92c82bb989b2a80f8fb8b5707f4165443e796

Children:

124a20ea0ece36b7e067b4b033f65127f2cee14a

git-committer:

Philipp Kern <phil@0x539.de> / 2007-01-06T22:57:10Z+0000

Message:

[project @ Gobby seems to work now, but still needs further testing]

Original author: Armin Burgmeier <armin@…>
Date: 2006-02-23 15:40:50+00:00

Files:

• inc/document.hpp (modified) (6 diffs)
• inc/docwindow.hpp (modified) (2 diffs)
• src/document.cpp (modified) (19 diffs)
• src/docwindow.cpp (modified) (3 diffs)
• src/hostprogressdialog.cpp (modified) (1 diff)
• src/joinprogressdialog.cpp (modified) (1 diff)

inc/document.hpp

@@ -24 +24 @@
 #include <obby/user_table.hpp>
 #include <obby/text.hpp>
+#include <obby/local_buffer.hpp>
+#include "gselector.hpp"
 #include "sourceview/sourcebuffer.hpp"
 
@@ -91 +93 @@
         };
 
+        // TODO: Only take user table as soon as the user table has signals
+        // like on_user_join and on_user_part
         class template_type
         {
         public:
+                // buffer_def cannot be included since it depends on this file
+                typedef obby::basic_local_buffer<Document, GSelector>
+                        buffer_type;
+
                 template_type(); // Default ctor, needed by obby, invalid
-                template_type(const obby::user_table& user_table);
-
-                const obby::user_table& get_user_table() const;
+                template_type(const buffer_type& buffer);
+
+                const buffer_type& get_buffer() const;
 
         protected:
-                const obby::user_table* m_user_table;
+                const buffer_type* m_buffer;
         };
+
+        typedef sigc::signal<void, obby::position, const std::string>
+                signal_insert_type;
+        typedef sigc::signal<void, obby::position, obby::position>
+                signal_erase_type;
 
         /** @brief Creates a new document that belongs to the given buffer.
@@ -162 +175 @@
          */
         Glib::RefPtr<Gtk::SourceBuffer> get_buffer() const;
+
+        /** @brief Signal that is emitted when the local user wants to insert
+         * text.
+         */
+        signal_insert_type insert_event() const;
+
+        /** @brief Signal that is emitted when the local user wants to erase
+         * text.
+         */
+        signal_erase_type erase_event() const;
 protected:
         typedef std::list<Glib::RefPtr<const Gtk::TextTag> > tag_list_type;
@@ -174 +197 @@
          */
         void on_user_color(const obby::user& user);
+
+        /** @brief Callback when text is inserted. This tells obby to insert
+         * text into the document.
+         */
+        void on_insert_before(const Gtk::TextIter& iter,
+                              const Glib::ustring& text);
+
+        /** @brief Callback when text is inserted. This tags newly inserted
+         * text.
+         */
+        void on_insert_after(const Gtk::TextIter& iter,
+                             const Glib::ustring& text);
+
+        /** @brief Callback when text is erased. This tells obby to erase
+         * text from the document.
+         */
+        void on_erase_before(const Gtk::TextIter& begin,
+                             const Gtk::TextIter& end);
+
+        /** @brief Denies application of tags we do not want.
+         */
+        void on_apply_tag_before(const Glib::RefPtr<Gtk::TextTag>& tag,
+                                 const Gtk::TextIter& begin,
+                                 const Gtk::TextIter& end);
 
         /** @brief Returns an iterator that points at the given position.
@@ -211 +258 @@
                                   const std::string& str,
                                   const obby::user* author);
+
+        /** @brief Tags a given range of text as written by <em>with</em>.
+         */
+        void tag_text(const Gtk::TextIter& begin,
+                      const Gtk::TextIter& end,
+                      const obby::user* with);
 
         /** @brief Helper class to use Glib::RefPtr<Gtk::TextTag> as index
@@ -239 +292 @@
         map_user_type m_map_user;
         map_tag_type m_map_tag;
-
+        const obby::user& m_self;
+
+        // Whether text is currently edited, needed to prevent recursion
+        // in signal emission
+        bool m_editing;
         Glib::RefPtr<Gtk::SourceBuffer> m_buffer;
+
+        signal_insert_type m_signal_insert;
+        signal_erase_type m_signal_erase;
 };
 

inc/docwindow.hpp

@@ -90 +90 @@
         bool get_modified() const; // TODO: Remove this in favor of get_document().get_buffer()->get_modified()
 
+        /** @brief Gives the focus to the underlaying sourceview instead of
+         * the scrolled window containing it.
+         */
+        void grab_focus();
+
         /** @brief Returns the current Gtk::SourceLanguage the document is
          * highlighted with.
@@ -152 +157 @@
         void on_changed();
 
+        /** @brief Callback when text has to be inserted.
+         */
+        void on_insert(obby::position pos,
+                       const std::string& text);
+
+        /** @brief Callback when text has to be erased.
+         */
+        void on_erase(obby::position pos,
+                      obby::position len);
+
         /** @brief Helper function that applies the preferences to the buffer.
          */

src/document.cpp

@@ -39 +39 @@
         void forward_bytes(Gtk::TextIter& iter, std::size_t bytes)
         {
-                while(bytes > 0)
+                while(bytes > 0 && !iter.is_end() )
                 {
                         std::size_t remaining_bytes =
@@ -49 +49 @@
                                 iter.set_line_index(
                                         iter.get_line_index() +
-                                        remaining_bytes
+                                        bytes
                                 );
 
@@ -60 +60 @@
 
                         bytes -= remaining_bytes;
+                }
+
+                if(bytes > 0 && iter.is_end() )
+                {
+                        throw std::logic_error(
+                                "document.cpp:forward_bytes:\n"
+                                "Bytes to forward exceed buffer size"
+                        );
                 }
         }
@@ -95 +103 @@
         }
 
-}
-
-// TODO: Apply tags to self-written text
+        class editor: private net6::non_copyable
+        {
+        public:
+                editor(bool& edit_var):
+                        m_edit_var(edit_var)
+                {
+                        if(m_edit_var == true)
+                        {
+                                throw std::logic_error(
+                                        "document.cpp:editor::editor:\n"
+                                        "Edit var is already true"
+                                );
+                        }
+
+                        m_edit_var = true;
+                }
+
+                ~editor()
+                {
+                        m_edit_var = false;
+                }
+
+        private:
+                bool& m_edit_var;
+        };
+}
 
 Gobby::Document::chunk_iterator::chunk_iterator(const Document& doc,
@@ -119 +150 @@
 Gobby::Document::chunk_iterator& Gobby::Document::chunk_iterator::operator++()
 {
+        m_author = m_next_author;
         m_iter_begin = m_iter_end;
+
         proceed_end();
+        return *this;
 }
 
@@ -144 +178 @@
 void Gobby::Document::chunk_iterator::proceed_end()
 {
-        m_author = m_next_author;
+        //m_author = m_next_author;
         m_next_author = m_doc.forward_chunk(m_iter_end);
 }
 
 Gobby::Document::template_type::template_type():
-        m_user_table(NULL)
+        m_buffer(NULL)
 {
 }
 
 Gobby::Document::template_type::
-        template_type(const obby::user_table& user_table):
-        m_user_table(&user_table)
-{
-}
-
-const obby::user_table& Gobby::Document::template_type::get_user_table() const
-{
-        if(m_user_table == NULL)
+        template_type(const buffer_type& buffer):
+        m_buffer(&buffer)
+{
+}
+
+const Gobby::Document::template_type::buffer_type&
+Gobby::Document::template_type::get_buffer() const
+{
+        if(m_buffer == NULL)
         {
                 throw std::logic_error(
-                        "Gobby::Document::template_type::get_user_table:\n"
-                        "Invalid template, no user table present"
+                        "Gobby::Document::template_type::get_buffer:\n"
+                        "Invalid template, no buffer present"
                 );
         }
 
-        return *m_user_table;
+        return *m_buffer;
 }
 
 Gobby::Document::Document(const template_type& tmpl):
-        m_buffer(Gtk::SourceBuffer::create() )
-{
-        const obby::user_table& table = tmpl.get_user_table();
+        m_self(tmpl.get_buffer().get_self() ),
+        m_editing(false), m_buffer(Gtk::SourceBuffer::create() )
+{
+        const template_type::buffer_type& buf = tmpl.get_buffer();
+        const obby::user_table& table = buf.get_user_table();
+
         for(obby::user_table::iterator iter =
                 table.begin(obby::user::flags::NONE, obby::user::flags::NONE);
@@ -184 +222 @@
         }
 
+        m_buffer->signal_insert().connect(
+                sigc::hide(sigc::mem_fun(*this, &Document::on_insert_before)),
+                false
+        );
+
+        m_buffer->signal_insert().connect(
+                sigc::hide(sigc::mem_fun(*this, &Document::on_insert_after)),
+                true
+        );
+
+        m_buffer->signal_erase().connect(
+                sigc::mem_fun(*this, &Document::on_erase_before),
+                false
+        );
+
+        m_buffer->signal_apply_tag().connect(
+                sigc::mem_fun(*this, &Document::on_apply_tag_before),
+                false
+        );
+
         // TODO: Connect to user table's signal handler - as soon as it
         // has some...
-/*      buf.user_join_event().connect(
+        buf.user_join_event().connect(
                 sigc::mem_fun(*this, &Document::on_user_join) );
         buf.user_colour_event().connect(
-                sigc::mem_fun(*this, &Document::on_user_color) );*/
+                sigc::mem_fun(*this, &Document::on_user_color) );
 }
 
@@ -249 +307 @@
                 );
         }
+
+        return result;
 }
 
@@ -264 +324 @@
                              const obby::text& str)
 {
+        if(m_editing) return;
+        editor edit(m_editing);
+
         Gtk::TextIter iter = get_iter(pos);
         insert_impl(iter, str);
@@ -272 +335 @@
                              const obby::user* author)
 {
+        if(m_editing) return;
+        editor edit(m_editing);
+
         Gtk::TextIter iter = get_iter(pos);
         insert_impl(iter, str, author);
@@ -278 +344 @@
 void Gobby::Document::erase(obby::position pos, obby::position len)
 {
+        if(m_editing) return;
+        editor edit(m_editing);
+
         Gtk::TextIter begin = get_iter(pos);
         Gtk::TextIter end = begin;
@@ -287 +356 @@
 void Gobby::Document::append(const obby::text& str)
 {
+        if(m_editing) return;
+        editor edit(m_editing);
+
         insert_impl(m_buffer->end(), str);
 }
@@ -293 +365 @@
                              const obby::user* author)
 {
+        if(m_editing) return;
+        editor edit(m_editing);
+
         insert_impl(m_buffer->end(), str, author);
 }
@@ -299 +374 @@
 {
         return m_buffer;
+}
+
+Gobby::Document::signal_insert_type Gobby::Document::insert_event() const
+{
+        return m_signal_insert;
+}
+
+Gobby::Document::signal_erase_type Gobby::Document::erase_event() const
+{
+        return m_signal_erase;
 }
 
@@ -336 +421 @@
 }
 
+void Gobby::Document::on_insert_before(const Gtk::TextIter& iter,
+                                       const Glib::ustring& text)
+{
+        // Only local edits that are not done via insert
+        if(m_editing) return;
+        editor edit(m_editing);
+
+        m_signal_insert.emit(diff_bytes(m_buffer->begin(), iter), text);
+}
+
+void Gobby::Document::on_insert_after(const Gtk::TextIter& iter,
+                                      const Glib::ustring& text)
+{
+        if(m_editing) return;
+        editor edit(m_editing);
+
+        Gtk::TextIter begin = iter;
+        begin.backward_chars(text.length() );
+
+        tag_text(begin, iter, &m_self);
+}
+
+void Gobby::Document::on_erase_before(const Gtk::TextIter& begin,
+                                      const Gtk::TextIter& end)
+{
+        // Only local edits that are not done via erase
+        if(m_editing) return;
+
+        editor edit(m_editing);
+        m_signal_erase.emit(
+                diff_bytes(m_buffer->begin(), begin),
+                diff_bytes(begin, end)
+        );
+}
+
+void Gobby::Document::on_apply_tag_before(const Glib::RefPtr<Gtk::TextTag>& tag,
+                                          const Gtk::TextIter& begin,
+                                          const Gtk::TextIter& end)
+{
+        if(m_map_tag.find(tag) != m_map_tag.end() && !m_editing)
+                m_buffer->signal_apply_tag().emission_stop();
+}
+
 Gtk::TextIter Gobby::Document::get_iter(obby::position at) const
 {
         Gtk::TextIter pos;
         for(pos = m_buffer->begin();
-            at > 0 && pos != m_buffer->end();
-            pos.forward_line() )
+            at > 0 && pos != m_buffer->end();)
         {
                 obby::position new_bytes = pos.get_bytes_in_line();
+
                 if(new_bytes > at)
                 {
                         pos.set_line_index(at);
-                        return pos;
+                        new_bytes = at;
+                }
+                else
+                {
+                        pos.forward_line();
                 }
 
@@ -361 +493 @@
         }
 
-        return m_buffer->end();
+        return pos; //m_buffer->end();
 }
 
@@ -375 +507 @@
         }
 
-        return false;
+        return NULL;
 }
 
@@ -427 +559 @@
                                            const obby::user* author)
 {
-        if(author != NULL)
-        {
-                map_user_type::const_iterator user_it =
-                        m_map_user.find(author);
+        Gtk::TextIter result = m_buffer->insert(iter, str);
+
+        Gtk::TextIter begin = result;
+        begin.backward_chars(g_utf8_strlen(str.c_str(), -1));
+
+        tag_text(begin, result, author);
+        return result;
+
+        return result;
+}
+
+Gtk::TextIter Gobby::Document::insert_impl(const Gtk::TextIter& iter,
+                                           const obby::text& str)
+{
+        Gtk::TextIter pos = iter;
+
+        for(obby::text::chunk_iterator chunk_it = str.chunk_begin();
+            chunk_it != str.chunk_end();
+            ++ chunk_it)
+        {
+                pos = insert_impl(
+                        pos,
+                        chunk_it->get_text(),
+                        chunk_it->get_author()
+                );
+        }
+
+        return pos;
+}
+
+void Gobby::Document::tag_text(const Gtk::TextIter& begin,
+                               const Gtk::TextIter& end,
+                               const obby::user* with)
+{
+        for(map_user_type::const_iterator user_iter = m_map_user.begin();
+            user_iter != m_map_user.end();
+            ++ user_iter)
+        {
+                m_buffer->remove_tag(user_iter->second, begin, end);
+        }
+
+        if(with != NULL)
+        {
+                map_user_type::const_iterator user_it = m_map_user.find(with);
 
                 if(user_it == m_map_user.end() )
@@ -440 +612 @@
                 }
 
-                // TODO: Remove all other tags.
-                // TODO: on_apply_tag_after
-                return m_buffer->insert_with_tag(iter, str, user_it->second);
-        }
-        else
-        {
-                // TODO: Remove all other tags.
-                // TODO: on_apply_tag_after
-                return m_buffer->insert(iter, str);
-        }
-}
-
-Gtk::TextIter Gobby::Document::insert_impl(const Gtk::TextIter& iter,
-                                           const obby::text& str)
-{
-        Gtk::TextIter pos = iter;
-
-        for(obby::text::chunk_iterator chunk_it = str.chunk_begin();
-            chunk_it != str.chunk_end();
-            ++ chunk_it)
-        {
-                pos = insert_impl(
-                        pos,
-                        chunk_it->get_text(),
-                        chunk_it->get_author()
-                );
-        }
-
-        return pos;
-}
+                m_buffer->apply_tag(user_it->second, begin, end);
+        }
+}
+
 #if 0
 

src/docwindow.cpp

@@ -73 +73 @@
         );
 
+        m_doc.insert_event().connect(
+                sigc::mem_fun(*this, &DocWindow::on_insert)
+        );
+
+        m_doc.erase_event().connect(
+                sigc::mem_fun(*this, &DocWindow::on_erase)
+        );
+
         apply_preferences();
         buf->set_modified(!m_doc.empty() );
@@ -148 +156 @@
 }
 
+void Gobby::DocWindow::grab_focus()
+{
+        m_view.grab_focus();
+}
+
 Glib::RefPtr<Gtk::SourceLanguage> Gobby::DocWindow::get_language() const
 {
@@ -226 +239 @@
         m_signal_cursor_moved.emit();
         m_signal_content_changed.emit();
+}
+
+void Gobby::DocWindow::on_insert(obby::position pos,
+                                 const std::string& error)
+{
+        m_info.insert(pos, error);
+}
+
+void Gobby::DocWindow::on_erase(obby::position pos,
+                                obby::position len)
+{
+        m_info.erase(pos, len);
 }
 

src/hostprogressdialog.cpp

@@ -80 +80 @@
                 buffer->set_document_template(
                         HostBuffer::document_type::template_type(
-                                buffer->get_user_table()
+                                *buffer
                         )
                 );

src/joinprogressdialog.cpp

@@ -131 +131 @@
                 buffer->set_document_template(
                         ClientBuffer::document_type::template_type(
-                                buffer->get_user_table()
+                                *buffer
                         )
                 );