Changeset 1d79f148669cfa7e22a001b0c897a60553bd3487

Timestamp:

01/06/07 23:32:12 (6 years ago)

Author:

Philipp Kern <phil@…>

Parents:

16c77f334ee68143eb93d92cd5b5fd39a9495ede

Children:

6460a27fda60372c9a6f37ce5f654de90a0eebaf

git-committer:

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

Message:

[project @ Some GtkSourceView? wrapper fixes and extensions]

Original author: Armin Burgmeier <armin@…>
Date: 2005-04-22 20:50:25+00:00

Files:

• inc/sourceview/private/sourcebuffer_p.hpp (modified) (1 diff)
• inc/sourceview/sourcebuffer.hpp (modified) (3 diffs)
• inc/sourceview/sourcelanguage.hpp (modified) (1 diff)
• inc/sourceview/sourcelanguagesmanager.hpp (modified) (1 diff)
• src/sourceview/sourcebuffer.cpp (modified) (5 diffs)
• src/sourceview/sourcelanguage.cpp (modified) (2 diffs)
• src/sourceview/sourcelanguagesmanager.cpp (modified) (2 diffs)

inc/sourceview/private/sourcebuffer_p.hpp

@@ -50 +50 @@
         // by overriding the *_impl method.
         // TODO: .
+        static void can_undo_callback(GtkSourceBuffer* self, gboolean can_undo);
+        static void can_redo_callback(GtkSourceBuffer* self, gboolean can_redo);
+        static void highlight_updated_callback(GtkSourceBuffer* self,
+                                               GtkTextIter* begin,
+                                               GtkTextIter* end);
+        static void marker_updated_callback(GtkSourceBuffer* self,
+                                            GtkTextIter* pos);
 
         // Callbacks (virtual functions):

inc/sourceview/sourcebuffer.hpp

@@ -25 +25 @@
 #include <gtkmm/textbuffer.h>
 #include <gtksourceview/gtksourcebuffer.h>
+#include "sourceview/sourcelanguage.hpp"
 
 typedef struct _GtkSourceBuffer GtkSourceBuffer;
@@ -55 +56 @@
 
 public:
+        typedef TextBuffer::iterator iterator;
+
         virtual ~SourceBuffer();
 
@@ -68 +71 @@
 protected:
         // Default Signal handlers
-        // ...
+        virtual void on_can_undo(bool can_undo);
+        virtual void on_can_redo(bool can_redo);
+        virtual void on_highlight_updated(const iterator& begin,
+                                          const iterator& end);
+        virtual void on_marker_updated(const iterator& pos);
+
 protected:
         SourceBuffer();
+        explicit SourceBuffer(const Glib::RefPtr<SourceLanguage>& language);
         // explicit SourceBuffer(const Glib::RefPtr<TagTable>& tag_table);
 
 public:
         static Glib::RefPtr<SourceBuffer> create();
+        static Glib::RefPtr<SourceBuffer> create(
+                const Glib::RefPtr<SourceLanguage>& language
+        );
+
         // static Glib::RefPtr<SourceBuffer> create(const Glib::RefPtr<TagTable>& tag_table);
+
+        bool get_check_brackets() const;
+        void set_check_brackets(bool check_brackets);
+//      void set_bracket_match_style(const Glib::RefPtr<SourceTagStyle>& style);
         
+        bool get_highlight() const;
+        void set_highlight(bool highlight);
+
+        gint get_max_undo_levels() const;
+        void set_max_undo_levels(gint max_undo_levels);
+
+        Glib::RefPtr<SourceLanguage> get_language() const;
+        void set_language(const Glib::RefPtr<SourceLanguage> language);
+
+        gunichar get_escape_char() const;
+        void set_escape_char(gunichar escape_char);
+
+        bool can_undo() const;
+        bool can_redo() const;
+
+        void undo();
+        void redo();
+
+        void begin_not_undoable_action();
+        void end_not_undoable_action();
+
+        // TODO: Marker stuff
+
+        Glib::SignalProxy1<void, bool> signal_can_undo();
+        Glib::SignalProxy1<void, bool> signal_can_redo();
+        Glib::SignalProxy2<void, const iterator&, const iterator&>
+                signal_highlight_updated();
+        Glib::SignalProxy1<void, const iterator&> signal_marker_updated();
 };
 

inc/sourceview/sourcelanguage.hpp

@@ -53 +53 @@
         SourceLanguage& operator=(const SourceLanguage& other);
 
-protected:
+//protected:
+// TODO: SourceLanguage() is needed by Glib::wrap(), but should be protected,
+// though...
+public:
+        SourceLanguage();
         explicit SourceLanguage(const Glib::ConstructParams& construct_params);
         explicit SourceLanguage(GtkSourceLanguage* castitem);

inc/sourceview/sourcelanguagesmanager.hpp

@@ -76 +76 @@
 
 public:
+        static Glib::RefPtr<SourceLanguagesManager> create();
+
         Glib::SListHandle<Glib::RefPtr<SourceLanguage> > 
                 get_available_languages() const;

src/sourceview/sourcebuffer.cpp

@@ -40 +40 @@
         CppClassParent::class_init_function(klass, class_data);
 
-        // Hier irgendwelche Signale.
+        klass->can_undo = &can_undo_callback;
+        klass->can_redo = &can_redo_callback;
+        klass->highlight_updated = &highlight_updated_callback;
+        klass->marker_updated = &marker_updated_callback;
+}
+
+void Gtk::SourceBuffer_Class::can_undo_callback(GtkSourceBuffer* self,
+                                                gboolean can_undo)
+{
+        CppObjectType* const obj = dynamic_cast<CppObjectType*>(
+                Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+        if(obj && obj->is_derived_() )
+        {
+                try
+                {
+                        obj->on_can_undo(can_undo == TRUE);
+                }
+                catch(...)
+                {
+                        Glib::exception_handlers_invoke();
+                }
+        }
+        else
+        {
+                BaseClassType* const base = static_cast<BaseClassType*>(
+                        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self))
+                );
+
+                if(base && base->can_undo)
+                        (*base->can_undo)(self, can_undo);
+        }
+}
+
+void Gtk::SourceBuffer_Class::can_redo_callback(GtkSourceBuffer* self,
+                                                gboolean can_redo)
+{
+        CppObjectType* const obj = dynamic_cast<CppObjectType*>(
+                Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+        if(obj && obj->is_derived_() )
+        {
+                try
+                {
+                        obj->on_can_redo(can_redo == TRUE);
+                }
+                catch(...)
+                {
+                        Glib::exception_handlers_invoke();
+                }
+        }
+        else
+        {
+                BaseClassType* const base = static_cast<BaseClassType*>(
+                        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self))
+                );
+
+                if(base && base->can_redo)
+                        (*base->can_redo)(self, can_redo);
+        }
+}
+
+void Gtk::SourceBuffer_Class::highlight_updated_callback(GtkSourceBuffer* self,
+                                                         GtkTextIter* begin,
+                                                         GtkTextIter* end)
+{
+        CppObjectType* const obj = dynamic_cast<CppObjectType*>(
+                Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+        if(obj && obj->is_derived_() )
+        {
+                try
+                {
+                        obj->on_highlight_updated(
+                                Glib::wrap(begin),
+                                Glib::wrap(end)
+                        );
+                }
+                catch(...)
+                {
+                        Glib::exception_handlers_invoke();
+                }
+        }
+        else
+        {
+                BaseClassType* const base = static_cast<BaseClassType*>(
+                        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self))
+                );
+
+                if(base && base->highlight_updated)
+                        (*base->highlight_updated)(self, begin, end);
+        }
+}
+
+void Gtk::SourceBuffer_Class::marker_updated_callback(GtkSourceBuffer* self,
+                                                      GtkTextIter* pos)
+{
+        CppObjectType* const obj = dynamic_cast<CppObjectType*>(
+                Glib::ObjectBase::_get_current_wrapper((GObject*)self));
+
+        if(obj && obj->is_derived_() )
+        {
+                try
+                {
+                        obj->on_marker_updated(Glib::wrap(pos) );
+                }
+                catch(...)
+                {
+                        Glib::exception_handlers_invoke();
+                }
+        }
+        else
+        {
+                BaseClassType* const base = static_cast<BaseClassType*>(
+                        g_type_class_peek_parent(G_OBJECT_GET_CLASS(self))
+                );
+
+                if(base && base->marker_updated)
+                        (*base->marker_updated)(self, pos);
+        }
 }
 
@@ -46 +165 @@
 {
         return new SourceBuffer( (GtkSourceBuffer*)o);
+}
+
+namespace
+{
+
+void SourceBuffer_signal_can_undo_callback(GtkSourceBuffer* self,
+                                           gboolean can_undo,
+                                           void* data)
+{
+        using namespace Gtk;
+        typedef sigc::slot<void, bool> SlotType;
+
+        if(Glib::ObjectBase::_get_current_wrapper((GObject*)self) )
+        {
+                try
+                {
+                        sigc::slot_base* const slot = 
+                                Glib::SignalProxyNormal::data_to_slot(data);
+
+                        if(slot)
+                                (*static_cast<SlotType*>(slot))(
+                                        can_undo == TRUE
+                                );
+                }
+                catch(...)
+                {
+                        Glib::exception_handlers_invoke();
+                }
+        }
+}
+
+const Glib::SignalProxyInfo SourceBuffer_signal_can_undo_info = 
+{
+        "can_undo",
+        (GCallback) &SourceBuffer_signal_can_undo_callback,
+        (GCallback) &SourceBuffer_signal_can_undo_callback
+};
+
+void SourceBuffer_signal_can_redo_callback(GtkSourceBuffer* self,
+                                           gboolean can_redo,
+                                           void* data)
+{
+        using namespace Gtk;
+        typedef sigc::slot<void, bool> SlotType;
+
+        if(Glib::ObjectBase::_get_current_wrapper((GObject*)self) )
+        {
+                try
+                {
+                        sigc::slot_base* const slot = 
+                                Glib::SignalProxyNormal::data_to_slot(data);
+
+                        if(slot)
+                                (*static_cast<SlotType*>(slot))(
+                                        can_redo == TRUE
+                                );
+                }
+                catch(...)
+                {
+                        Glib::exception_handlers_invoke();
+                }
+        }
+}
+
+const Glib::SignalProxyInfo SourceBuffer_signal_can_redo_info = 
+{
+        "can_redo",
+        (GCallback) &SourceBuffer_signal_can_redo_callback,
+        (GCallback) &SourceBuffer_signal_can_redo_callback
+};
+
+void SourceBuffer_signal_highlight_updated_callback(GtkSourceBuffer* self,
+                                                    GtkTextIter* begin,
+                                                    GtkTextIter* end,
+                                                    void* data)
+{
+        using namespace Gtk;
+        typedef sigc::slot<
+                void,
+                const SourceBuffer::iterator&,
+                const SourceBuffer::iterator&
+        > SlotType;
+
+        if(Glib::ObjectBase::_get_current_wrapper((GObject*)self) )
+        {
+                try
+                {
+                        sigc::slot_base* const slot = 
+                                Glib::SignalProxyNormal::data_to_slot(data);
+
+                        if(slot)
+                                (*static_cast<SlotType*>(slot))(
+                                        Glib::wrap(begin),
+                                        Glib::wrap(end)
+                                );
+                }
+                catch(...)
+                {
+                        Glib::exception_handlers_invoke();
+                }
+        }
+}
+
+const Glib::SignalProxyInfo SourceBuffer_signal_highlight_updated_info = 
+{
+        "highlight_updated",
+        (GCallback) &SourceBuffer_signal_highlight_updated_callback,
+        (GCallback) &SourceBuffer_signal_highlight_updated_callback
+};
+
+void SourceBuffer_signal_marker_updated_callback(GtkSourceBuffer* self,
+                                                 GtkTextIter* pos,
+                                                 void* data)
+{
+        using namespace Gtk;
+        typedef sigc::slot<
+                void,
+                const SourceBuffer::iterator&
+        > SlotType;
+
+        if(Glib::ObjectBase::_get_current_wrapper((GObject*)self) )
+        {
+                try
+                {
+                        sigc::slot_base* const slot = 
+                                Glib::SignalProxyNormal::data_to_slot(data);
+
+                        if(slot)
+                                (*static_cast<SlotType*>(slot))(
+                                        Glib::wrap(pos)
+                                );
+                }
+                catch(...)
+                {
+                        Glib::exception_handlers_invoke();
+                }
+        }
+}
+
+const Glib::SignalProxyInfo SourceBuffer_signal_marker_updated_info = 
+{
+        "marker_updated",
+        (GCallback) &SourceBuffer_signal_marker_updated_callback,
+        (GCallback) &SourceBuffer_signal_marker_updated_callback
+};
+
 }
 
@@ -51 +316 @@
  : Gtk::TextBuffer(Glib::ConstructParams(sourcebuffer_class_.init()) )
 {
+}
+
+Gtk::SourceBuffer::SourceBuffer(const Glib::RefPtr<SourceLanguage>& language)
+ : Gtk::TextBuffer(Glib::ConstructParams(sourcebuffer_class_.init()) )
+{
+        set_language(language);
 }
 
@@ -98 +369 @@
 }
 
+Glib::RefPtr<Gtk::SourceBuffer>
+Gtk::SourceBuffer::create(const Glib::RefPtr<SourceLanguage>& language)
+{
+        return Glib::RefPtr<SourceBuffer>(new SourceBuffer(language) );
+}
+
 /*Glib::RefPtr<Gtk::SourceBuffer>
 Gtk::SourceBuffer::create(const Glib::RefPtr<TagTable>& tag_table)
@@ -103 +380 @@
         return Glib::RefPtr<SourceBuffer>(new SourceBuffer(tag_table) );
 }*/
+
+void Gtk::SourceBuffer::on_can_undo(bool can_undo)
+{
+        BaseClassType* const base = static_cast<BaseClassType*>(
+                g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_))
+        );
+
+        if(base && base->can_undo)
+                (*base->can_undo)(gobj(), can_undo ? TRUE : FALSE);
+}
+
+void Gtk::SourceBuffer::on_can_redo(bool can_redo)
+{
+        BaseClassType* const base = static_cast<BaseClassType*>(
+                g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_))
+        );
+
+        if(base && base->can_redo)
+                (*base->can_redo)(gobj(), can_redo ? TRUE : FALSE);
+}
+
+void Gtk::SourceBuffer::on_highlight_updated(const iterator& begin,
+                                             const iterator& end)
+{
+        BaseClassType* const base = static_cast<BaseClassType*>(
+                g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_))
+        );
+
+        if(base && base->highlight_updated)
+                (*base->highlight_updated)(
+                        gobj(),
+                        const_cast<GtkTextIter*>(begin.gobj()),
+                        const_cast<GtkTextIter*>(end.gobj())
+                );
+}
+
+void Gtk::SourceBuffer::on_marker_updated(const iterator& pos)
+{
+        BaseClassType* const base = static_cast<BaseClassType*>(
+                g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_))
+        );
+
+        if(base && base->marker_updated)
+                (*base->marker_updated)(
+                        gobj(),
+                        const_cast<GtkTextIter*>(pos.gobj())
+                );
+}
+
+Glib::SignalProxy1<void, bool> Gtk::SourceBuffer::signal_can_undo()
+{
+        return Glib::SignalProxy1<void, bool>(
+                this,
+                &SourceBuffer_signal_can_undo_info
+        );
+}
+
+Glib::SignalProxy1<void, bool> Gtk::SourceBuffer::signal_can_redo()
+{
+        return Glib::SignalProxy1<void, bool>(
+                this,
+                &SourceBuffer_signal_can_redo_info
+        );
+}
+
+Glib::SignalProxy2<
+        void,
+        const Gtk::SourceBuffer::iterator&,
+        const Gtk::SourceBuffer::iterator&
+> Gtk::SourceBuffer::signal_highlight_updated()
+{
+        return Glib::SignalProxy2<void, const iterator&, const iterator&>(
+                this,
+                &SourceBuffer_signal_highlight_updated_info
+        );
+}
+
+Glib::SignalProxy1<
+        void,
+        const Gtk::SourceBuffer::iterator&
+> Gtk::SourceBuffer::signal_marker_updated()
+{
+        return Glib::SignalProxy1<void, const iterator&>(
+                this,
+                &SourceBuffer_signal_marker_updated_info
+        );
+}
+
+bool Gtk::SourceBuffer::get_check_brackets() const
+{
+        return gtk_source_buffer_get_check_brackets(
+                const_cast<GtkSourceBuffer*>(gobj())
+        ) == TRUE;
+}
+
+void Gtk::SourceBuffer::set_check_brackets(bool check_brackets)
+{
+        return gtk_source_buffer_set_check_brackets(
+                gobj(),
+                check_brackets ? TRUE : FALSE
+        );
+}
+
+/*void Gtk::SourceBuffer::set_bracket_match_style(
+        const Glib::RefPtr<Gtk::SourceTagStyle>& style
+)
+{
+        gtk_source_buffer_set_bracket_match_style(
+                const_cast<GtkSourceBuffer*>(gobj() ),
+                style->gobj()
+        );
+}*/
+
+bool Gtk::SourceBuffer::get_highlight() const
+{
+        return gtk_source_buffer_get_highlight(
+                const_cast<GtkSourceBuffer*>(gobj())
+        ) == TRUE;
+}
+
+void Gtk::SourceBuffer::set_highlight(bool highlight)
+{
+        gtk_source_buffer_set_highlight(
+                gobj(),
+                highlight ? TRUE : FALSE
+        );
+}
+
+gint Gtk::SourceBuffer::get_max_undo_levels() const
+{
+        return gtk_source_buffer_get_max_undo_levels(
+                const_cast<GtkSourceBuffer*>(gobj())
+        );
+}
+
+void Gtk::SourceBuffer::set_max_undo_levels(gint max_undo_levels)
+{
+        gtk_source_buffer_set_max_undo_levels(
+                gobj(),
+                max_undo_levels
+        );      
+}
+
+Glib::RefPtr<Gtk::SourceLanguage> Gtk::SourceBuffer::get_language() const
+{
+        return Glib::wrap(gtk_source_buffer_get_language(
+                const_cast<GtkSourceBuffer*>(gobj())
+        ) );
+}
+
+void
+Gtk::SourceBuffer::set_language(const Glib::RefPtr<SourceLanguage> language)
+{
+        // Add new reference to the language because the C instance holds a
+        // new reference now.
+        g_object_ref(G_OBJECT(language->gobj()) );
+
+        gtk_source_buffer_set_language(
+                gobj(),
+                language->gobj()
+        );
+}
+
+gunichar Gtk::SourceBuffer::get_escape_char() const
+{
+        return gtk_source_buffer_get_escape_char(
+                const_cast<GtkSourceBuffer*>(gobj())
+        );
+}
+
+void Gtk::SourceBuffer::set_escape_char(gunichar escape_char)
+{
+        gtk_source_buffer_set_escape_char(
+                gobj(),
+                escape_char
+        );
+}
+
+bool Gtk::SourceBuffer::can_undo() const
+{
+        return gtk_source_buffer_can_undo(
+                const_cast<GtkSourceBuffer*>(gobj())
+        );
+}
+
+bool Gtk::SourceBuffer::can_redo() const
+{
+        return gtk_source_buffer_can_redo(
+                const_cast<GtkSourceBuffer*>(gobj())
+        );
+}
+
+void Gtk::SourceBuffer::undo()
+{
+        gtk_source_buffer_undo(gobj() );
+}
+
+void Gtk::SourceBuffer::redo()
+{
+        gtk_source_buffer_redo(gobj() );
+}
+
+void Gtk::SourceBuffer::begin_not_undoable_action()
+{
+        gtk_source_buffer_begin_not_undoable_action(gobj() );
+}
+
+void Gtk::SourceBuffer::end_not_undoable_action()
+{
+        gtk_source_buffer_end_not_undoable_action(gobj() );
+}
 
 Glib::RefPtr<Gtk::SourceBuffer>

src/sourceview/sourcelanguage.cpp

@@ -46 +46 @@
 {
         return new SourceLanguage(reinterpret_cast<GtkSourceLanguage*>(o) );
+}
+
+Gtk::SourceLanguage::SourceLanguage()
+ : Glib::Object(Glib::ConstructParams(sourcelanguage_class_.init()))
+{
 }
 
@@ -141 +146 @@
 Glib::wrap(GtkSourceLanguage* object, bool take_copy)
 {
-        return Glib::RefPtr<Gtk::SourceLanguage>(
+        // The Code below does not work - don't know why
+        return Glib::RefPtr<Gtk::SourceLanguage>(new Gtk::SourceLanguage(GTK_SOURCE_LANGUAGE( (GObject*)(object))));
+/*      return Glib::RefPtr<Gtk::SourceLanguage>(
                 dynamic_cast<Gtk::SourceLanguage*>(Glib::wrap_auto(
                         reinterpret_cast<GObject*>(object),
                         take_copy
                 ) )
-        );
+        );*/
 }

src/sourceview/sourcelanguagesmanager.cpp

@@ -89 +89 @@
 }
 
+Glib::RefPtr<Gtk::SourceLanguagesManager>
+Gtk::SourceLanguagesManager::create()
+{
+        return Glib::RefPtr<SourceLanguagesManager>(new SourceLanguagesManager);
+}
+
 Glib::SListHandle<Glib::RefPtr<Gtk::SourceLanguage> >
 Gtk::SourceLanguagesManager::get_available_languages() const
@@ -111 +117 @@
                         const_cast<GtkSourceLanguagesManager*>(gobj()),
                         mime_type.c_str()
-                ) // TODO: Take new copy?
+                ),
+                true 
         );