nyje
/
medit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

More private/public api separation

master
Yevgen Muntyan 2006-08-15 03:21:44 -05:00
parent aba4d55c8a
commit 6273534c82
28 changed files with 675 additions and 630 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
moo/mooedit/mooedit-actions.c
View File

@ -257,7 +257,7 @@ moo_edit_class_new_actionv (MooEditClass *klass,
goto error;
}
action_type = moo_value_get_gtype (&param.value);
action_type = _moo_value_get_gtype (&param.value);
if (!g_type_is_a (action_type, MOO_TYPE_ACTION_BASE))
{
@ -341,7 +341,7 @@ moo_edit_class_new_actionv (MooEditClass *klass,
goto error;
}
moo_param_array_free ((GParameter*) action_params->data, action_params->len);
_moo_param_array_free ((GParameter*) action_params->data, action_params->len);
g_array_free (action_params, FALSE);
action_params = NULL;

28
moo/mooedit/mooedit.c
View File

@ -181,22 +181,22 @@ moo_edit_class_init (MooEditClass *klass)
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE);
signals[COMMENT] =
moo_signal_new_cb ("comment",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_edit_comment),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("comment",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_edit_comment),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[UNCOMMENT] =
moo_signal_new_cb ("uncomment",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_edit_uncomment),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("uncomment",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_edit_uncomment),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[SAVE_BEFORE] =
g_signal_new ("save-before",

2
moo/mooedit/mooeditconfig.c
View File

@ -755,7 +755,7 @@ moo_edit_config_parse_one (MooEditConfig *config,
if (G_PARAM_SPEC_VALUE_TYPE (pspec) == G_TYPE_BOOLEAN)
result = parse_boolean (value, &gval);
else
result = moo_value_convert_from_string (value, &gval);
result = _moo_value_convert_from_string (value, &gval);
if (result)
moo_edit_config_set_value (config, prop_id, source, &gval);

12
moo/mooedit/mooeditor.c
View File

@ -248,12 +248,12 @@ moo_editor_class_init (MooEditorClass *klass)
G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
signals[ALL_WINDOWS_CLOSED] =
moo_signal_new_cb ("all-windows-closed",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
NULL, NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("all-windows-closed",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
NULL, NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
edit_window_class = g_type_class_ref (MOO_TYPE_EDIT_WINDOW);
moo_window_class_new_action_custom (edit_window_class, RECENT_ACTION_ID, NULL,

2
moo/mooedit/mooeditwindow.c
View File

@ -2422,7 +2422,7 @@ save_pane_params (const char *pane_id,
if (params->position >= 0)
moo_markup_set_prop (node, PROP_PANE_POSITION,
moo_convert_int_to_string (params->position));
_moo_convert_int_to_string (params->position));
else
moo_markup_set_prop (node, PROP_PANE_POSITION, NULL);

12
moo/mooedit/moolangmgr.c
View File

@ -49,12 +49,12 @@ moo_lang_mgr_class_init (MooLangMgrClass *klass)
gobject_class->finalize = moo_lang_mgr_finalize;
moo_signal_new_cb ("loaded",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
NULL, NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("loaded",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
NULL, NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}

52
moo/mooedit/moolineview.c
View File

@ -92,13 +92,13 @@ static void moo_line_view_class_init (MooLineViewClass *klass)
G_TYPE_INT);
signals[ACTIVATE_CURRENT_LINE] =
moo_signal_new_cb ("activate-current-line",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (activate_current_line),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("activate-current-line",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (activate_current_line),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
binding_set = gtk_binding_set_by_class (klass);
@ -111,9 +111,9 @@ static void moo_line_view_init (MooLineView *view)
{
view->priv = g_new0 (MooLineViewPrivate, 1);
view->priv->line_data = moo_data_new (g_direct_hash,
g_direct_equal,
NULL);
view->priv->line_data = _moo_data_new (g_direct_hash,
g_direct_equal,
NULL);
g_object_set (view,
"editable", FALSE,
@ -128,7 +128,7 @@ static void moo_line_view_finalize (GObject *object)
{
MooLineView *view = MOO_LINE_VIEW (object);
moo_data_destroy (view->priv->line_data);
_moo_data_destroy (view->priv->line_data);
g_free (view->priv);
G_OBJECT_CLASS (moo_line_view_parent_class)->finalize (object);
@ -154,7 +154,7 @@ moo_line_view_clear (MooLineView *view)
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_delete (buffer, &start, &end);
moo_data_clear (view->priv->line_data);
_moo_data_clear (view->priv->line_data);
}
@ -336,11 +336,11 @@ moo_line_view_set_data (MooLineView *view,
g_return_if_fail (line >= 0);
if (data)
moo_data_insert_ptr (view->priv->line_data,
GINT_TO_POINTER (line),
data, free_func);
_moo_data_insert_ptr (view->priv->line_data,
GINT_TO_POINTER (line),
data, free_func);
else
moo_data_remove (view->priv->line_data, GINT_TO_POINTER (line));
_moo_data_remove (view->priv->line_data, GINT_TO_POINTER (line));
}
@ -350,8 +350,8 @@ moo_line_view_get_data (MooLineView *view,
{
g_return_val_if_fail (MOO_IS_LINE_VIEW (view), NULL);
g_return_val_if_fail (line >= 0, NULL);
return moo_data_get_ptr (view->priv->line_data,
GINT_TO_POINTER (line));
return _moo_data_get_ptr (view->priv->line_data,
GINT_TO_POINTER (line));
}
@ -587,12 +587,12 @@ moo_line_view_set_line_data (MooLineView *view,
g_return_if_fail (!data || G_IS_VALUE (data));
if (data)
moo_data_insert_value (view->priv->line_data,
GINT_TO_POINTER (line),
data);
_moo_data_insert_value (view->priv->line_data,
GINT_TO_POINTER (line),
data);
else
moo_data_remove (view->priv->line_data,
GINT_TO_POINTER (line));
_moo_data_remove (view->priv->line_data,
GINT_TO_POINTER (line));
}
@ -604,7 +604,7 @@ moo_line_view_get_line_data (MooLineView *view,
g_return_val_if_fail (MOO_IS_LINE_VIEW (view), FALSE);
g_return_val_if_fail (line >= 0, FALSE);
g_return_val_if_fail (!G_IS_VALUE (dest), FALSE);
return moo_data_get_value (view->priv->line_data,
GINT_TO_POINTER (line),
dest);
return _moo_data_get_value (view->priv->line_data,
GINT_TO_POINTER (line),
dest);
}

32
moo/mooedit/mootextbuffer.c
View File

@ -249,24 +249,24 @@ moo_text_buffer_class_init (MooTextBufferClass *klass)
G_TYPE_NONE, 0);
signals[HIGHLIGHTING_CHANGED] =
moo_signal_new_cb ("highlighting-changed",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
NULL, NULL, NULL,
_moo_marshal_VOID__BOXED_BOXED,
G_TYPE_NONE, 2,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
_moo_signal_new_cb ("highlighting-changed",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
NULL, NULL, NULL,
_moo_marshal_VOID__BOXED_BOXED,
G_TYPE_NONE, 2,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
signals[TAGS_CHANGED] =
moo_signal_new_cb ("tags-changed",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
NULL, NULL, NULL,
_moo_marshal_VOID__BOXED_BOXED,
G_TYPE_NONE, 2,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
_moo_signal_new_cb ("tags-changed",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
NULL, NULL, NULL,
_moo_marshal_VOID__BOXED_BOXED,
G_TYPE_NONE, 2,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
signals[LINE_MARK_ADDED] =
g_signal_new ("line-mark-added",

42
moo/mooedit/mootextview.c
View File

@ -519,13 +519,13 @@ static void moo_text_view_class_init (MooTextViewClass *klass)
G_TYPE_BOOLEAN, 0);
signals[DELETE_SELECTION] =
moo_signal_new_cb ("delete-selection",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_CALLBACK (moo_text_view_delete_selection),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("delete-selection",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
G_CALLBACK (moo_text_view_delete_selection),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[FIND_WORD_AT_CURSOR] =
g_signal_new ("find-word-at-cursor",
@ -594,13 +594,13 @@ static void moo_text_view_class_init (MooTextViewClass *klass)
G_TYPE_UINT);
signals[CURSOR_MOVED] =
moo_signal_new_cb ("cursor-moved",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
NULL, NULL, NULL,
_moo_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
_moo_signal_new_cb ("cursor-moved",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST,
NULL, NULL, NULL,
_moo_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
signals[SET_SCHEME] =
g_signal_new ("set-scheme",
@ -623,13 +623,13 @@ static void moo_text_view_class_init (MooTextViewClass *klass)
G_TYPE_INT);
signals[START_QUICK_SEARCH] =
moo_signal_new_cb ("start-quick-search",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (start_quick_search),
NULL, NULL,
_moo_marshal_BOOL__VOID,
G_TYPE_BOOLEAN, 0);
_moo_signal_new_cb ("start-quick-search",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (start_quick_search),
NULL, NULL,
_moo_marshal_BOOL__VOID,
G_TYPE_BOOLEAN, 0);
binding_set = gtk_binding_set_by_class (klass);
gtk_binding_entry_add_signal (binding_set, GDK_z, GDK_CONTROL_MASK,

14
moo/moofileview/moofileentry.c
View File

@ -213,13 +213,13 @@ _moo_file_entry_completion_class_init (MooFileEntryCompletionClass *klass)
G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
signals[FINISHED] =
moo_signal_new_cb ("finished",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (completion_finished),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("finished",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (completion_finished),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}

30
moo/moofileview/moofileview.c
View File

@ -595,7 +595,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
GTK_TYPE_MENU);
signals[GO_UP] =
moo_signal_new_cb ("go-up",
_moo_signal_new_cb("go-up",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_file_view_go_up),
@ -604,7 +604,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[GO_FORWARD] =
moo_signal_new_cb ("go-forward",
_moo_signal_new_cb("go-forward",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_file_view_go_forward),
@ -613,7 +613,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[GO_BACK] =
moo_signal_new_cb ("go-back",
_moo_signal_new_cb("go-back",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_file_view_go_back),
@ -622,7 +622,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[GO_HOME] =
moo_signal_new_cb ("go-home",
_moo_signal_new_cb("go-home",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_file_view_go_home),
@ -631,7 +631,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[FOCUS_TO_FILTER_ENTRY] =
moo_signal_new_cb ("focus-to-filter-entry",
_moo_signal_new_cb("focus-to-filter-entry",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (focus_to_filter_entry),
@ -640,7 +640,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[FOCUS_TO_FILE_VIEW] =
moo_signal_new_cb ("focus-to-file-view",
_moo_signal_new_cb("focus-to-file-view",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (focus_to_file_view),
@ -649,7 +649,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[TOGGLE_SHOW_HIDDEN] =
moo_signal_new_cb ("toggle-show-hidden",
_moo_signal_new_cb("toggle-show-hidden",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (toggle_show_hidden),
@ -658,7 +658,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[DELETE_TO_CURSOR] =
moo_signal_new_cb ("delete-to-cursor",
_moo_signal_new_cb("delete-to-cursor",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (path_entry_delete_to_cursor),
@ -667,7 +667,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[DELETE_SELECTED] =
moo_signal_new_cb ("delete-selected",
_moo_signal_new_cb("delete-selected",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_delete_selected),
@ -676,7 +676,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[CREATE_FOLDER] =
moo_signal_new_cb ("create-folder",
_moo_signal_new_cb("create-folder",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_create_folder),
@ -685,7 +685,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[PROPERTIES_DIALOG] =
moo_signal_new_cb ("properties-dialog",
_moo_signal_new_cb("properties-dialog",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_properties_dialog),
@ -694,7 +694,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[RELOAD] =
moo_signal_new_cb ("reload",
_moo_signal_new_cb("reload",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_file_view_reload),
@ -735,7 +735,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_UINT);
signals[CUT_CLIPBOARD] =
moo_signal_new_cb ("cut-clipboard",
_moo_signal_new_cb("cut-clipboard",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_cut_clipboard),
@ -744,7 +744,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[COPY_CLIPBOARD] =
moo_signal_new_cb ("copy-clipboard",
_moo_signal_new_cb("copy-clipboard",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_copy_clipboard),
@ -753,7 +753,7 @@ moo_file_view_class_init (MooFileViewClass *klass)
G_TYPE_NONE, 0);
signals[PASTE_CLIPBOARD] =
moo_signal_new_cb ("paste-clipboard",
_moo_signal_new_cb("paste-clipboard",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (file_view_paste_clipboard),

32
moo/moofileview/mooiconview.c
View File

@ -335,24 +335,24 @@ _moo_icon_view_class_init (MooIconViewClass *klass)
widget_class->set_scroll_adjustments_signal = signals[SET_SCROLL_ADJUSTMENTS];
signals[ACTIVATE_ITEM_AT_CURSOR] =
moo_signal_new_cb ("activate-item-at-cursor",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (activate_item_at_cursor),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("activate-item-at-cursor",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (activate_item_at_cursor),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[MOVE_CURSOR] =
moo_signal_new_cb ("move-cursor",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (move_cursor),
NULL, NULL,
_moo_marshal_BOOLEAN__ENUM_INT_BOOLEAN,
G_TYPE_BOOLEAN, 3,
GTK_TYPE_MOVEMENT_STEP,
G_TYPE_INT, G_TYPE_BOOLEAN);
_moo_signal_new_cb ("move-cursor",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (move_cursor),
NULL, NULL,
_moo_marshal_BOOLEAN__ENUM_INT_BOOLEAN,
G_TYPE_BOOLEAN, 3,
GTK_TYPE_MOVEMENT_STEP,
G_TYPE_INT, G_TYPE_BOOLEAN);
binding_set = gtk_binding_set_by_class (klass);

47
moo/moopython/pygtk/mooutils-pygtk.defs
View File

@ -247,7 +247,6 @@
(include "moofileview.defs")
(include "subdir/moofileview.defs")
;; Enumerations and flags ...
@ -2171,31 +2170,31 @@
)
)
(define-function watch_add_signal
(c-name "moo_watch_add_signal")
(return-type "none")
(parameters
'("guint" "watch_id")
'("const-char*" "source_signal")
)
)
;; (define-function watch_add_signal
;; (c-name "moo_watch_add_signal")
;; (return-type "none")
;; (parameters
;; '("guint" "watch_id")
;; '("const-char*" "source_signal")
;; )
;; )
(define-function watch_add_property
(c-name "moo_watch_add_property")
(return-type "none")
(parameters
'("guint" "watch_id")
'("const-char*" "source_prop")
)
)
;; (define-function watch_add_property
;; (c-name "moo_watch_add_property")
;; (return-type "none")
;; (parameters
;; '("guint" "watch_id")
;; '("const-char*" "source_prop")
;; )
;; )
(define-function watch_remove
(c-name "moo_watch_remove")
(return-type "gboolean")
(parameters
'("guint" "watch_id")
)
)
;; (define-function watch_remove
;; (c-name "moo_watch_remove")
;; (return-type "gboolean")
;; (parameters
;; '("guint" "watch_id")
;; )
;; )
;;;;;;;;;;;;;

16
moo/mooterm/mooterm.c
View File

@ -220,14 +220,14 @@ static void moo_term_class_init (MooTermClass *klass)
GTK_TYPE_MENU);
signals[SET_WIDTH] =
moo_signal_new_cb ("set-width",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL, /* handler */
NULL, NULL,
_moo_marshal_VOID__UINT,
G_TYPE_NONE, 1,
G_TYPE_UINT);
_moo_signal_new_cb ("set-width",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL, /* handler */
NULL, NULL,
_moo_marshal_VOID__UINT,
G_TYPE_NONE, 1,
G_TYPE_UINT);
signals[APPLY_SETTINGS] =
g_signal_new ("apply-settings",

104
moo/mooterm/mootermbuffer.c
View File

@ -82,33 +82,33 @@ static void moo_term_buffer_class_init (MooTermBufferClass *klass)
gobject_class->finalize = moo_term_buffer_finalize;
signals[CHANGED] =
moo_signal_new_cb ("changed",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("changed",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[CURSOR_MOVED] =
moo_signal_new_cb ("cursor-moved",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("cursor-moved",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[FEED_CHILD] =
moo_signal_new_cb ("feed-child",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__STRING_INT,
G_TYPE_NONE, 2,
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE,
G_TYPE_INT);
_moo_signal_new_cb ("feed-child",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__STRING_INT,
G_TYPE_NONE, 2,
G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE,
G_TYPE_INT);
signals[FULL_RESET] =
g_signal_new ("full-reset",
@ -120,41 +120,41 @@ static void moo_term_buffer_class_init (MooTermBufferClass *klass)
G_TYPE_NONE, 0);
signals[TABS_CHANGED] =
moo_signal_new_cb ("tabs-changed",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("tabs-changed",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[SCREEN_SIZE_CHANGED] =
moo_signal_new_cb ("screen-size-changed",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("screen-size-changed",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[NEW_LINE] =
moo_signal_new_cb ("new-line",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("new-line",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[SCROLLED] =
moo_signal_new_cb ("scrolled",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__UINT,
G_TYPE_NONE, 1,
G_TYPE_UINT);
_moo_signal_new_cb ("scrolled",
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL,
_moo_marshal_VOID__UINT,
G_TYPE_NONE, 1,
G_TYPE_UINT);
g_object_class_install_property (gobject_class,
PROP_SCREEN_WIDTH,

1
moo/mooutils/Makefile.am
View File

@ -116,6 +116,7 @@ mooutils_sources = \
mooundo.c \
mooutils-fs.h \
mooutils-fs.c \
mooutils-gobject-private.h \
mooutils-gobject.c \
mooutils-misc.c \
mooutils-treeview.h \

4
moo/mooutils/mooaction.c
View File

@ -566,8 +566,8 @@ toggle_watch_new (GObject *master,
return NULL;
}
watch = moo_object_watch_new (ToggleWatch, &ToggleWatchClass,
master, action, NULL, NULL);
watch = _moo_object_watch_new (ToggleWatch, &ToggleWatchClass,
master, action, NULL, NULL);
watch->pspec = pspec;
watch->invert = invert;

12
moo/mooutils/mooactionfactory.c
View File

@ -29,7 +29,7 @@ moo_action_factory_dispose (GObject *object)
if (factory->props)
{
moo_param_array_free (factory->props, factory->n_props);
_moo_param_array_free (factory->props, factory->n_props);
factory->props = NULL;
factory->n_props = 0;
}
@ -138,7 +138,7 @@ collect_valist (GType type,
g_warning ("%s: could not find property '%s' for class '%s'",
G_STRLOC, prop_name, g_type_name (type));
moo_param_array_free ((GParameter*) props->data, props->len);
_moo_param_array_free ((GParameter*) props->data, props->len);
g_array_free (props, FALSE);
g_type_class_unref (klass);
@ -157,7 +157,7 @@ collect_valist (GType type,
g_value_unset (&param.value);
g_free ((char*)param.name);
moo_param_array_free ((GParameter*) props->data, props->len);
_moo_param_array_free ((GParameter*) props->data, props->len);
g_array_free (props, FALSE);
g_type_class_unref (klass);
@ -283,8 +283,8 @@ moo_action_factory_create_action (MooActionFactory *factory,
object = g_object_newv (factory->action_type, n_props, props);
moo_param_array_free (props, n_props);
moo_param_array_free (add_props, n_add_props);
_moo_param_array_free (props, n_props);
_moo_param_array_free (add_props, n_add_props);
return object;
}
@ -336,7 +336,7 @@ moo_action_factory_new_a (GType action_type,
g_warning ("%s: could not find property '%s' for class '%s'",
G_STRLOC, prop_name, g_type_name (action_type));
moo_param_array_free ((GParameter*) props->data, props->len);
_moo_param_array_free ((GParameter*) props->data, props->len);
g_array_free (props, FALSE);
g_type_class_unref (klass);

2
moo/mooutils/mooconfig.c
View File

@ -1152,7 +1152,7 @@ moo_config_get_bool (MooConfig *config,
string = moo_config_item_get (item, key);
default_val = get_default_bool (config, key);
return moo_convert_string_to_bool (string, default_val);
return _moo_convert_string_to_bool (string, default_val);
}

14
moo/mooutils/mooentry.c
View File

@ -241,13 +241,13 @@ moo_entry_class_init (MooEntryClass *klass)
G_TYPE_NONE, 0);
signals[DELETE_TO_START] =
moo_signal_new_cb ("delete-to-start",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_entry_delete_to_start),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
_moo_signal_new_cb ("delete-to-start",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (moo_entry_delete_to_start),
NULL, NULL,
_moo_marshal_VOID__VOID,
G_TYPE_NONE, 0);
binding_set = gtk_binding_set_by_class (klass);
gtk_binding_entry_add_signal (binding_set, GDK_z,

10
moo/mooutils/mooglade.c
View File

@ -1051,7 +1051,7 @@ widget_props_free (WidgetProps *props)
if (props)
{
if (props->params)
moo_param_array_free (props->params, props->n_params);
_moo_param_array_free (props->params, props->n_params);
if (props->custom_props)
{
@ -1074,7 +1074,7 @@ packing_props_free (PackingProps *props)
if (props)
{
if (props->params)
moo_param_array_free (props->params, props->n_params);
_moo_param_array_free (props->params, props->n_params);
g_free (props);
}
}
@ -1569,7 +1569,7 @@ widget_props_new (MooMarkupNode *node,
return props;
error:
moo_param_array_free ((GParameter*) params->data, params->len);
_moo_param_array_free ((GParameter*) params->data, params->len);
g_array_free (params, FALSE);
g_type_class_unref (klass);
widget_props_free (props);
@ -1630,7 +1630,7 @@ packing_props_new (MooMarkupNode *node,
MOO_GLADE_XML_ERROR_FAILED,
"could not find property '%s'",
name);
moo_param_array_free ((GParameter*) params->data, params->len);
_moo_param_array_free ((GParameter*) params->data, params->len);
g_array_free (params, FALSE);
g_type_class_unref (klass);
packing_props_free (props);
@ -1647,7 +1647,7 @@ packing_props_new (MooMarkupNode *node,
MOO_GLADE_XML_ERROR_FAILED,
"could not convert '%s' to property '%s'",
value, name);
moo_param_array_free ((GParameter*) params->data, params->len);
_moo_param_array_free ((GParameter*) params->data, params->len);
g_array_free (params, FALSE);
g_type_class_unref (klass);
packing_props_free (props);

12
moo/mooutils/moomarkup.c
View File

@ -726,8 +726,8 @@ moo_markup_get_int_prop (MooMarkupNode *node,
{
g_return_val_if_fail (MOO_MARKUP_IS_ELEMENT (node), default_val);
g_return_val_if_fail (prop_name != NULL, default_val);
return moo_convert_string_to_int (moo_markup_get_prop (node, prop_name),
default_val);
return _moo_convert_string_to_int (moo_markup_get_prop (node, prop_name),
default_val);
}
@ -737,7 +737,7 @@ moo_markup_set_int_prop (MooMarkupNode *node,
int val)
{
moo_markup_set_prop (node, prop_name,
moo_convert_int_to_string (val));
_moo_convert_int_to_string (val));
}
@ -748,8 +748,8 @@ moo_markup_get_bool_prop (MooMarkupNode *node,
{
g_return_val_if_fail (MOO_MARKUP_IS_ELEMENT (node), default_val);
g_return_val_if_fail (prop_name != NULL, default_val);
return moo_convert_string_to_bool (moo_markup_get_prop (node, prop_name),
default_val);
return _moo_convert_string_to_bool (moo_markup_get_prop (node, prop_name),
default_val);
}
@ -759,7 +759,7 @@ moo_markup_set_bool_prop (MooMarkupNode *node,
gboolean val)
{
moo_markup_set_prop (node, prop_name,
moo_convert_bool_to_string (val));
_moo_convert_bool_to_string (val));
}

28
moo/mooutils/mooprefs.c
View File

@ -211,7 +211,7 @@ moo_prefs_new_key (const char *key,
const GValue *default_value)
{
g_return_if_fail (key != NULL);
g_return_if_fail (moo_value_type_supported (value_type));
g_return_if_fail (_moo_value_type_supported (value_type));
g_return_if_fail (default_value != NULL);
g_return_if_fail (G_VALUE_TYPE (default_value) == value_type);
@ -313,7 +313,7 @@ prefs_new_key (MooPrefs *prefs,
g_return_if_fail (key && key[0]);
g_return_if_fail (g_utf8_validate (key, -1, NULL));
g_return_if_fail (moo_value_type_supported (type));
g_return_if_fail (_moo_value_type_supported (type));
g_return_if_fail (G_IS_VALUE (default_value));
g_return_if_fail (G_VALUE_TYPE (default_value) == type);
@ -365,7 +365,7 @@ prefs_new_key_from_string (MooPrefs *prefs,
}
else
{
moo_value_convert (&val, &item->value);
_moo_value_convert (&val, &item->value);
}
g_value_unset (&val);
@ -496,7 +496,7 @@ item_new (GType type,
{
PrefsItem *item;
g_return_val_if_fail (moo_value_type_supported (type), NULL);
g_return_val_if_fail (_moo_value_type_supported (type), NULL);
g_return_val_if_fail (value && default_value, NULL);
g_return_val_if_fail (G_VALUE_TYPE (value) == type, NULL);
g_return_val_if_fail (G_VALUE_TYPE (default_value) == type, NULL);
@ -519,13 +519,13 @@ item_set_type (PrefsItem *item,
GType type)
{
g_return_val_if_fail (item != NULL, FALSE);
g_return_val_if_fail (moo_value_type_supported (type), FALSE);
g_return_val_if_fail (_moo_value_type_supported (type), FALSE);
if (type != item->type)
{
item->type = type;
moo_value_change_type (&item->value, type);
moo_value_change_type (&item->default_value, type);
_moo_value_change_type (&item->value, type);
_moo_value_change_type (&item->default_value, type);
return TRUE;
}
@ -570,7 +570,7 @@ item_set (PrefsItem *item,
g_return_val_if_fail (G_IS_VALUE (value), FALSE);
g_return_val_if_fail (item->type == G_VALUE_TYPE (value), FALSE);
if (!moo_value_equal (value, &item->value))
if (!_moo_value_equal (value, &item->value))
{
g_value_copy (value, &item->value);
return TRUE;
@ -588,7 +588,7 @@ item_set_default (PrefsItem *item,
g_return_val_if_fail (G_IS_VALUE (value), FALSE);
g_return_val_if_fail (item->type == G_VALUE_TYPE (value), FALSE);
if (!moo_value_equal (value, &item->default_value))
if (!_moo_value_equal (value, &item->default_value))
{
g_value_copy (value, &item->default_value);
return TRUE;
@ -979,9 +979,9 @@ write_item (const char *key,
g_return_if_fail (key != NULL && key[0] != 0);
g_return_if_fail (item != NULL && stuff != NULL);
g_return_if_fail (moo_value_type_supported (item->type));
g_return_if_fail (_moo_value_type_supported (item->type));
if (moo_value_equal (item_value (item), item_default_value (item)))
if (_moo_value_equal (item_value (item), item_default_value (item)))
{
#ifdef DEBUG_READWRITE
g_print ("skipping '%s'\n", key);
@ -989,7 +989,7 @@ write_item (const char *key,
return;
}
string = moo_value_convert_to_string (item_value (item));
string = _moo_value_convert_to_string (item_value (item));
if (!string)
string = "";
@ -1236,7 +1236,7 @@ moo_prefs_get_number (const char *key)
value = moo_prefs_get (key);
g_return_val_if_fail (value != NULL, 0);
return moo_value_convert_to_double (value);
return _moo_value_convert_to_double (value);
}
@ -1355,7 +1355,7 @@ moo_prefs_set_number (const char *key,
g_value_init (&double_val, G_TYPE_DOUBLE);
g_value_set_double (&double_val, val);
moo_value_convert (&double_val, &gval);
_moo_value_convert (&double_val, &gval);
moo_prefs_set (key, &gval);
}

2
moo/mooutils/mooprefsdialogpage.c
View File

@ -496,7 +496,7 @@ radio_button_get_value (GtkWidget *button,
val.g_type = 0;
g_value_init (&val, type);
if (moo_value_convert_from_string (string, &val))
if (_moo_value_convert_from_string (string, &val))
return g_value_get_enum (&val);
g_return_val_if_reached (-1);

182
moo/mooutils/mooutils-gobject-private.h Normal file
View File

@ -0,0 +1,182 @@
/*
* mooutils-gobject-private.h
*
* Copyright (C) 2004-2006 by Yevgen Muntyan <muntyan@math.tamu.edu>
*
* 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 2 of the License, or
* (at your option) any later version.
*
* See COPYING file that comes with this distribution.
*/
#ifndef __MOO_UTILS_GOBJECT_PRIVATE_H__
#define __MOO_UTILS_GOBJECT_PRIVATE_H__
#include <mooutils/mooutils-gobject.h>
G_BEGIN_DECLS
/*****************************************************************************/
/* GType type
*/
#define MOO_TYPE_PARAM_GTYPE (_moo_param_gtype_get_type())
#define MOO_IS_PARAM_SPEC_GTYPE(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), MOO_TYPE_PARAM_GTYPE))
#define MOO_PARAM_SPEC_GTYPE(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), MOO_TYPE_PARAM_GTYPE, MooParamSpecGType))
typedef struct _MooParamSpecGType MooParamSpecGType;
struct _MooParamSpecGType
{
GParamSpec parent;
GType base;
};
GType _moo_param_gtype_get_type (void) G_GNUC_CONST;
GParamSpec *_moo_param_spec_gtype (const char *name,
const char *nick,
const char *blurb,
GType base,
GParamFlags flags);
void _moo_value_set_gtype (GValue *value,
GType v_gtype);
/*****************************************************************************/
/* Converting values forth and back
*/
gboolean _moo_value_convert_to_bool (const GValue *val);
int _moo_value_convert_to_int (const GValue *val);
int _moo_value_convert_to_enum (const GValue *val,
GType enum_type);
int _moo_value_convert_to_flags (const GValue *val,
GType flags_type);
const GdkColor *_moo_value_convert_to_color (const GValue *val);
/*****************************************************************************/
/* GParameter array manipulation
*/
typedef GParamSpec* (*MooLookupProperty) (GObjectClass *klass,
const char *prop_name);
GParameter *_moo_param_array_collect (GType type,
MooLookupProperty lookup_func,
guint *len,
const char *first_prop_name,
...) G_GNUC_NULL_TERMINATED;
GParameter *_moo_param_array_collect_valist(GType type,
MooLookupProperty lookup_func,
guint *len,
const char *first_prop_name,
va_list var_args);
GParameter *_moo_param_array_add (GType type,
GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
...) G_GNUC_NULL_TERMINATED;
GParameter *_moo_param_array_add_valist (GType type,
GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
va_list var_args);
GParameter *_moo_param_array_add_type (GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
...) G_GNUC_NULL_TERMINATED;
GParameter *_moo_param_array_add_type_valist(GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
va_list var_args);
/*****************************************************************************/
/* Property watch
*/
guint _moo_bind_signal (gpointer target,
const char *target_signal,
gpointer source,
const char *source_signal);
gboolean _moo_sync_bool_property (gpointer slave,
const char *slave_prop,
gpointer master,
const char *master_prop,
gboolean invert);
void _moo_copy_boolean (GValue *target,
const GValue *source,
gpointer dummy);
void _moo_invert_boolean (GValue *target,
const GValue *source,
gpointer dummy);
typedef void (*MooTransformPropFunc) (GValue *target,
const GValue *source,
gpointer data);
typedef void (*MooGetPropFunc) (GObject *source,
GValue *target,
gpointer data);
guint _moo_add_property_watch (gpointer target,
const char *target_prop,
gpointer source,
const char *source_prop,
MooTransformPropFunc transform,
gpointer transform_data,
GDestroyNotify destroy_notify);
void _moo_watch_add_signal (guint watch_id,
const char *source_signal);
void _moo_watch_add_property (guint watch_id,
const char *source_prop);
gboolean _moo_watch_remove (guint watch_id);
/*****************************************************************************/
/* Data store
*/
#define MOO_TYPE_PTR (_moo_ptr_get_type ())
#define MOO_TYPE_DATA (_moo_data_get_type ())
typedef struct _MooPtr MooPtr;
struct _MooPtr {
guint ref_count;
gpointer data;
GDestroyNotify free_func;
};
GType _moo_ptr_get_type (void) G_GNUC_CONST;
GType _moo_data_get_type (void) G_GNUC_CONST;
/* There are no ref-counted NULL pointers! */
MooPtr *_moo_ptr_new (gpointer data,
GDestroyNotify free_func);
MooPtr *_moo_ptr_ref (MooPtr *ptr);
void _moo_ptr_unref (MooPtr *ptr);
guint _moo_data_size (MooData *data);
gboolean _moo_data_has_key (MooData *data,
gpointer key);
GType _moo_data_get_value_type (MooData *data,
gpointer key);
G_END_DECLS
#endif /* __MOO_UTILS_GOBJECT_PRIVATE_H__ */

386
moo/mooutils/mooutils-gobject.c
View File

@ -11,7 +11,7 @@
* See COPYING file that comes with this distribution.
*/
#include "mooutils/mooutils-gobject.h"
#include "mooutils/mooutils-gobject-private.h"
#include "mooutils/mooclosure.h"
#include <gobject/gvaluecollector.h>
#include <string.h>
@ -57,13 +57,13 @@ moo_gtype_lcopy_value (const GValue *value,
G_GNUC_UNUSED guint collect_flags)
{
GType *ptr = collect_values->v_pointer;
*ptr = moo_value_get_gtype (value);
*ptr = _moo_value_get_gtype (value);
return NULL;
}
GType
moo_gtype_get_type (void)
_moo_gtype_get_type (void)
{
static GType type = 0;
@ -107,15 +107,15 @@ moo_gtype_get_type (void)
void
moo_value_set_gtype (GValue *value,
GType v_gtype)
_moo_value_set_gtype (GValue *value,
GType v_gtype)
{
MOO_GTYPE_PEEK(value) = (gpointer) v_gtype;
}
GType
moo_value_get_gtype (const GValue *value)
_moo_value_get_gtype (const GValue *value)
{
return (GType) MOO_GTYPE_PEEK(value);
}
@ -126,7 +126,7 @@ param_gtype_set_default (GParamSpec *pspec,
GValue *value)
{
MooParamSpecGType *mspec = MOO_PARAM_SPEC_GTYPE (pspec);
moo_value_set_gtype (value, mspec->base);
_moo_value_set_gtype (value, mspec->base);
}
@ -135,20 +135,20 @@ param_gtype_validate (GParamSpec *pspec,
GValue *value)
{
MooParamSpecGType *mspec = MOO_PARAM_SPEC_GTYPE (pspec);
GType t = moo_value_get_gtype (value);
GType t = _moo_value_get_gtype (value);
gboolean changed = FALSE;
if (G_TYPE_IS_DERIVABLE (mspec->base))
{
if (!g_type_is_a (t, mspec->base))
{
moo_value_set_gtype (value, mspec->base);
_moo_value_set_gtype (value, mspec->base);
changed = TRUE;
}
}
else if (!g_type_name (t))
{
moo_value_set_gtype (value, mspec->base);
_moo_value_set_gtype (value, mspec->base);
changed = TRUE;
}
@ -161,14 +161,14 @@ param_gtype_cmp (G_GNUC_UNUSED GParamSpec *pspec,
const GValue *value1,
const GValue *value2)
{
GType t1 = moo_value_get_gtype (value1);
GType t2 = moo_value_get_gtype (value2);
GType t1 = _moo_value_get_gtype (value1);
GType t2 = _moo_value_get_gtype (value2);
return t1 == t2 ? 0 : (t1 < t2 ? -1 : 1);
}
GType
moo_param_gtype_get_type (void)
_moo_param_gtype_get_type (void)
{
static GType type = 0;
@ -194,11 +194,11 @@ moo_param_gtype_get_type (void)
GParamSpec*
moo_param_spec_gtype (const char *name,
const char *nick,
const char *blurb,
GType base,
GParamFlags flags)
_moo_param_spec_gtype (const char *name,
const char *nick,
const char *blurb,
GType base,
GParamFlags flags)
{
MooParamSpecGType *pspec;
@ -212,10 +212,6 @@ moo_param_spec_gtype (const char *name,
}
GType g_param_type_register_static (const gchar *name,
const GParamSpecTypeInfo *pspec_info);
/*****************************************************************************/
/* Converting values forth and back
*/
@ -248,7 +244,7 @@ string_to_flags (const char *string,
ival.g_type = 0;
g_value_init (&ival, G_TYPE_INT);
if (!moo_value_convert_from_string (string, &ival))
if (!_moo_value_convert_from_string (string, &ival))
return FALSE;
*flags = g_value_get_int (&ival);
@ -257,8 +253,8 @@ string_to_flags (const char *string,
gboolean
moo_value_convert (const GValue *src,
GValue *dest)
_moo_value_convert (const GValue *src,
GValue *dest)
{
GType src_type, dest_type;
@ -267,8 +263,8 @@ moo_value_convert (const GValue *src,
src_type = G_VALUE_TYPE (src);
dest_type = G_VALUE_TYPE (dest);
g_return_val_if_fail (moo_value_type_supported (src_type), FALSE);
g_return_val_if_fail (moo_value_type_supported (dest_type), FALSE);
g_return_val_if_fail (_moo_value_type_supported (src_type), FALSE);
g_return_val_if_fail (_moo_value_type_supported (dest_type), FALSE);
if (src_type == dest_type)
{
@ -563,8 +559,8 @@ moo_value_convert (const GValue *src,
gboolean
moo_value_equal (const GValue *a,
const GValue *b)
_moo_value_equal (const GValue *a,
const GValue *b)
{
GType type;
@ -629,7 +625,7 @@ moo_value_equal (const GValue *a,
gboolean
moo_value_type_supported (GType type)
_moo_value_type_supported (GType type)
{
return type == G_TYPE_BOOLEAN ||
type == G_TYPE_INT ||
@ -643,64 +639,64 @@ moo_value_type_supported (GType type)
gboolean
moo_value_convert_to_bool (const GValue *val)
_moo_value_convert_to_bool (const GValue *val)
{
GValue result;
result.g_type = 0;
g_value_init (&result, G_TYPE_BOOLEAN);
moo_value_convert (val, &result);
_moo_value_convert (val, &result);
return g_value_get_boolean (&result);
}
int
moo_value_convert_to_int (const GValue *val)
_moo_value_convert_to_int (const GValue *val)
{
GValue result;
result.g_type = 0;
g_value_init (&result, G_TYPE_INT);
moo_value_convert (val, &result);
_moo_value_convert (val, &result);
return g_value_get_int (&result);
}
int
moo_value_convert_to_enum (const GValue *val,
GType enum_type)
_moo_value_convert_to_enum (const GValue *val,
GType enum_type)
{
GValue result;
result.g_type = 0;
g_value_init (&result, enum_type);
moo_value_convert (val, &result);
_moo_value_convert (val, &result);
return g_value_get_enum (&result);
}
int
moo_value_convert_to_flags (const GValue *val,
GType flags_type)
_moo_value_convert_to_flags (const GValue *val,
GType flags_type)
{
GValue result;
result.g_type = 0;
g_value_init (&result, flags_type);
moo_value_convert (val, &result);
_moo_value_convert (val, &result);
return g_value_get_flags (&result);
}
double
moo_value_convert_to_double (const GValue *val)
_moo_value_convert_to_double (const GValue *val)
{
GValue result;
result.g_type = 0;
g_value_init (&result, G_TYPE_DOUBLE);
moo_value_convert (val, &result);
_moo_value_convert (val, &result);
return g_value_get_double (&result);
}
const GdkColor*
moo_value_convert_to_color (const GValue *val)
_moo_value_convert_to_color (const GValue *val)
{
static GValue result;
@ -709,7 +705,7 @@ moo_value_convert_to_color (const GValue *val)
g_value_init (&result, GDK_TYPE_COLOR);
if (!moo_value_convert (val, &result))
if (!_moo_value_convert (val, &result))
return NULL;
else
return g_value_get_boxed (&result);
@ -717,7 +713,7 @@ moo_value_convert_to_color (const GValue *val)
const char*
moo_value_convert_to_string (const GValue *val)
_moo_value_convert_to_string (const GValue *val)
{
static GValue result;
@ -726,7 +722,7 @@ moo_value_convert_to_string (const GValue *val)
g_value_init (&result, G_TYPE_STRING);
if (!moo_value_convert (val, &result))
if (!_moo_value_convert (val, &result))
return NULL;
else
return g_value_get_string (&result);
@ -734,8 +730,8 @@ moo_value_convert_to_string (const GValue *val)
gboolean
moo_value_convert_from_string (const char *string,
GValue *val)
_moo_value_convert_from_string (const char *string,
GValue *val)
{
GValue str_val;
gboolean result;
@ -746,7 +742,7 @@ moo_value_convert_from_string (const char *string,
str_val.g_type = 0;
g_value_init (&str_val, G_TYPE_STRING);
g_value_set_static_string (&str_val, string);
result = moo_value_convert (&str_val, val);
result = _moo_value_convert (&str_val, val);
g_value_unset (&str_val);
return result;
@ -754,8 +750,8 @@ moo_value_convert_from_string (const char *string,
int
moo_convert_string_to_int (const char *string,
int default_val)
_moo_convert_string_to_int (const char *string,
int default_val)
{
int int_val;
@ -765,7 +761,7 @@ moo_convert_string_to_int (const char *string,
str_val.g_type = 0;
g_value_init (&str_val, G_TYPE_STRING);
g_value_set_static_string (&str_val, string);
int_val = moo_value_convert_to_int (&str_val);
int_val = _moo_value_convert_to_int (&str_val);
g_value_unset (&str_val);
}
else
@ -778,8 +774,8 @@ moo_convert_string_to_int (const char *string,
gboolean
moo_convert_string_to_bool (const char *string,
gboolean default_val)
_moo_convert_string_to_bool (const char *string,
gboolean default_val)
{
gboolean bool_val;
@ -789,7 +785,7 @@ moo_convert_string_to_bool (const char *string,
str_val.g_type = 0;
g_value_init (&str_val, G_TYPE_STRING);
g_value_set_static_string (&str_val, string);
bool_val = moo_value_convert_to_bool (&str_val);
bool_val = _moo_value_convert_to_bool (&str_val);
g_value_unset (&str_val);
}
else
@ -802,7 +798,7 @@ moo_convert_string_to_bool (const char *string,
const char*
moo_convert_bool_to_string (gboolean value)
_moo_convert_bool_to_string (gboolean value)
{
GValue bool_val;
@ -810,12 +806,12 @@ moo_convert_bool_to_string (gboolean value)
g_value_init (&bool_val, G_TYPE_BOOLEAN);
g_value_set_boolean (&bool_val, value);
return moo_value_convert_to_string (&bool_val);
return _moo_value_convert_to_string (&bool_val);
}
const char*
moo_convert_int_to_string (int value)
_moo_convert_int_to_string (int value)
{
GValue int_val;
@ -823,23 +819,23 @@ moo_convert_int_to_string (int value)
g_value_init (&int_val, G_TYPE_INT);
g_value_set_int (&int_val, value);
return moo_value_convert_to_string (&int_val);
return _moo_value_convert_to_string (&int_val);
}
gboolean
moo_value_change_type (GValue *val,
GType new_type)
_moo_value_change_type (GValue *val,
GType new_type)
{
GValue tmp;
gboolean result;
g_return_val_if_fail (G_IS_VALUE (val), FALSE);
g_return_val_if_fail (moo_value_type_supported (new_type), FALSE);
g_return_val_if_fail (_moo_value_type_supported (new_type), FALSE);
tmp.g_type = 0;
g_value_init (&tmp, new_type);
result = moo_value_convert (val, &tmp);
result = _moo_value_convert (val, &tmp);
if (result)
{
@ -859,19 +855,19 @@ static void copy_param (GParameter *dest,
GParameter *src);
GParameter*
moo_param_array_collect (GType type,
MooLookupProperty lookup_func,
guint *len,
const char *first_prop_name,
...)
_moo_param_array_collect (GType type,
MooLookupProperty lookup_func,
guint *len,
const char *first_prop_name,
...)
{
GParameter *array;
va_list var_args;
va_start (var_args, first_prop_name);
array = moo_param_array_collect_valist (type, lookup_func, len,
first_prop_name,
var_args);
array = _moo_param_array_collect_valist (type, lookup_func, len,
first_prop_name,
var_args);
va_end (var_args);
return array;
@ -879,20 +875,20 @@ moo_param_array_collect (GType type,
GParameter*
moo_param_array_add (GType type,
GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
...)
_moo_param_array_add (GType type,
GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
...)
{
GParameter *copy;
va_list var_args;
va_start (var_args, first_prop_name);
copy = moo_param_array_add_valist (type, src, len, new_len,
first_prop_name,
var_args);
copy = _moo_param_array_add_valist (type, src, len, new_len,
first_prop_name,
var_args);
va_end (var_args);
return copy;
@ -900,19 +896,19 @@ moo_param_array_add (GType type,
GParameter*
moo_param_array_add_type (GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
...)
_moo_param_array_add_type (GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
...)
{
GParameter *copy;
va_list var_args;
va_start (var_args, first_prop_name);
copy = moo_param_array_add_type_valist (src, len, new_len,
first_prop_name,
var_args);
copy = _moo_param_array_add_type_valist (src, len, new_len,
first_prop_name,
var_args);
va_end (var_args);
return copy;
@ -920,12 +916,12 @@ moo_param_array_add_type (GParameter *src,
GParameter*
moo_param_array_add_valist (GType type,
GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
va_list var_args)
_moo_param_array_add_valist (GType type,
GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
va_list var_args)
{
const char *name;
GArray *copy;
@ -954,7 +950,7 @@ moo_param_array_add_valist (GType type,
if (!pspec) {
g_warning ("%s: class '%s' doesn't have property '%s'",
G_STRLOC, g_type_name (type), name);
moo_param_array_free ((GParameter*)copy->data, copy->len);
_moo_param_array_free ((GParameter*)copy->data, copy->len);
g_array_free (copy, FALSE);
return NULL;
}
@ -968,7 +964,7 @@ moo_param_array_add_valist (GType type,
g_free (error);
g_value_unset (&param.value);
g_free ((char*)param.name);
moo_param_array_free ((GParameter*)copy->data, copy->len);
_moo_param_array_free ((GParameter*)copy->data, copy->len);
g_array_free (copy, FALSE);
return NULL;
}
@ -984,11 +980,11 @@ moo_param_array_add_valist (GType type,
GParameter*
moo_param_array_add_type_valist (GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
va_list var_args)
_moo_param_array_add_type_valist (GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
va_list var_args)
{
const char *name;
GArray *copy;
@ -1015,7 +1011,7 @@ moo_param_array_add_type_valist (GParameter *src,
if (G_TYPE_FUNDAMENTAL (type) == G_TYPE_INVALID)
{
g_warning ("%s: invalid type id passed", G_STRLOC);
moo_param_array_free ((GParameter*)copy->data, copy->len);
_moo_param_array_free ((GParameter*)copy->data, copy->len);
g_array_free (copy, FALSE);
return NULL;
}
@ -1030,7 +1026,7 @@ moo_param_array_add_type_valist (GParameter *src,
g_free (error);
g_value_unset (&param.value);
g_free ((char*)param.name);
moo_param_array_free ((GParameter*)copy->data, copy->len);
_moo_param_array_free ((GParameter*)copy->data, copy->len);
g_array_free (copy, FALSE);
return NULL;
}
@ -1046,11 +1042,11 @@ moo_param_array_add_type_valist (GParameter *src,
GParameter*
moo_param_array_collect_valist (GType type,
MooLookupProperty lookup_func,
guint *len,
const char *first_prop_name,
va_list var_args)
_moo_param_array_collect_valist (GType type,
MooLookupProperty lookup_func,
guint *len,
const char *first_prop_name,
va_list var_args)
{
GObjectClass *klass;
GArray *params = NULL;
@ -1077,7 +1073,7 @@ moo_param_array_collect_valist (GType type,
{
g_warning ("%s: class '%s' doesn't have property '%s'",
G_STRLOC, g_type_name (type), prop_name);
moo_param_array_free ((GParameter*)params->data, params->len);
_moo_param_array_free ((GParameter*)params->data, params->len);
g_array_free (params, FALSE);
g_type_class_unref (klass);
return NULL;
@ -1094,7 +1090,7 @@ moo_param_array_collect_valist (GType type,
g_free (error);
g_value_unset (&param.value);
g_free ((char*)param.name);
moo_param_array_free ((GParameter*)params->data, params->len);
_moo_param_array_free ((GParameter*)params->data, params->len);
g_array_free (params, FALSE);
g_type_class_unref (klass);
return NULL;
@ -1113,8 +1109,8 @@ moo_param_array_collect_valist (GType type,
void
moo_param_array_free (GParameter *array,
guint len)
_moo_param_array_free (GParameter *array,
guint len)
{
guint i;
@ -1163,16 +1159,16 @@ void_closure_new (void)
guint
moo_signal_new_cb (const gchar *signal_name,
GType itype,
GSignalFlags signal_flags,
GCallback handler,
GSignalAccumulator accumulator,
gpointer accu_data,
GSignalCMarshaller c_marshaller,
GType return_type,
guint n_params,
...)
_moo_signal_new_cb (const gchar *signal_name,
GType itype,
GSignalFlags signal_flags,
GCallback handler,
GSignalAccumulator accumulator,
gpointer accu_data,
GSignalCMarshaller c_marshaller,
GType return_type,
guint n_params,
...)
{
va_list args;
guint signal_id;
@ -1207,8 +1203,8 @@ static guint watch_last_id = 0;
#define Watch MooObjectWatch
#define WatchClass MooObjectWatchClass
#define watch_new moo_object_watch_new
#define watch_alloc moo_object_watch_alloc
#define watch_new _moo_object_watch_new
#define watch_alloc _moo_object_watch_alloc
static void
@ -1368,13 +1364,13 @@ prop_watch_destroy (Watch *watch)
guint
moo_add_property_watch (gpointer target,
const char *target_prop,
gpointer source,
const char *source_prop,
MooTransformPropFunc transform,
gpointer transform_data,
GDestroyNotify destroy_notify)
_moo_add_property_watch (gpointer target,
const char *target_prop,
gpointer source,
const char *source_prop,
MooTransformPropFunc transform,
gpointer transform_data,
GDestroyNotify destroy_notify)
{
PropWatch *watch;
@ -1440,18 +1436,18 @@ prop_watch_check (PropWatch *watch)
void
moo_copy_boolean (GValue *target,
const GValue *source,
G_GNUC_UNUSED gpointer dummy)
_moo_copy_boolean (GValue *target,
const GValue *source,
G_GNUC_UNUSED gpointer dummy)
{
g_value_set_boolean (target, g_value_get_boolean (source) ? TRUE : FALSE);
}
void
moo_invert_boolean (GValue *target,
const GValue *source,
G_GNUC_UNUSED gpointer dummy)
_moo_invert_boolean (GValue *target,
const GValue *source,
G_GNUC_UNUSED gpointer dummy)
{
g_value_set_boolean (target, !g_value_get_boolean (source));
}
@ -1469,20 +1465,20 @@ moo_bind_bool_property (gpointer target,
g_return_val_if_fail (target_prop && source_prop, 0);
if (invert)
return moo_add_property_watch (target, target_prop, source, source_prop,
moo_invert_boolean, NULL, NULL);
return _moo_add_property_watch (target, target_prop, source, source_prop,
_moo_invert_boolean, NULL, NULL);
else
return moo_add_property_watch (target, target_prop, source, source_prop,
moo_copy_boolean, NULL, NULL);
return _moo_add_property_watch (target, target_prop, source, source_prop,
_moo_copy_boolean, NULL, NULL);
}
gboolean
moo_sync_bool_property (gpointer slave,
const char *slave_prop,
gpointer master,
const char *master_prop,
gboolean invert)
_moo_sync_bool_property (gpointer slave,
const char *slave_prop,
gpointer master,
const char *master_prop,
gboolean invert)
{
guint id1 = 0, id2 = 0;
@ -1493,7 +1489,7 @@ moo_sync_bool_property (gpointer slave,
id2 = moo_bind_bool_property (master, master_prop, slave, slave_prop, invert);
if (!id2)
moo_watch_remove (id1);
_moo_watch_remove (id1);
}
return id1 && id2;
@ -1516,7 +1512,7 @@ moo_bind_sensitive (GtkWidget *btn,
gboolean
moo_watch_remove (guint watch_id)
_moo_watch_remove (guint watch_id)
{
Watch *watch;
@ -1535,8 +1531,8 @@ moo_watch_remove (guint watch_id)
void
moo_watch_add_signal (guint watch_id,
const char *source_signal)
_moo_watch_add_signal (guint watch_id,
const char *source_signal)
{
Watch *watch;
@ -1554,15 +1550,15 @@ moo_watch_add_signal (guint watch_id,
void
moo_watch_add_property (guint watch_id,
const char *source_prop)
_moo_watch_add_property (guint watch_id,
const char *source_prop)
{
char *signal;
g_return_if_fail (source_prop != NULL);
signal = g_strdup_printf ("notify::%s", source_prop);
moo_watch_add_signal (watch_id, signal);
_moo_watch_add_signal (watch_id, signal);
g_free (signal);
}
@ -1684,10 +1680,10 @@ signal_watch_invoke (SignalWatch *watch)
guint
moo_bind_signal (gpointer target,
const char *target_signal,
gpointer source,
const char *source_signal)
_moo_bind_signal (gpointer target,
const char *target_signal,
gpointer source,
const char *source_signal)
{
SignalWatch *watch;
@ -1716,22 +1712,22 @@ struct _MooData
GType
moo_ptr_get_type (void)
_moo_ptr_get_type (void)
{
static GType type = 0;
if (!type)
type = g_boxed_type_register_static ("MooPtr",
(GBoxedCopyFunc) moo_ptr_ref,
(GBoxedFreeFunc) moo_ptr_unref);
(GBoxedCopyFunc) _moo_ptr_ref,
(GBoxedFreeFunc) _moo_ptr_unref);
return type;
}
MooPtr*
moo_ptr_new (gpointer data,
GDestroyNotify free_func)
_moo_ptr_new (gpointer data,
GDestroyNotify free_func)
{
MooPtr *ptr;
@ -1748,7 +1744,7 @@ moo_ptr_new (gpointer data,
MooPtr *
moo_ptr_ref (MooPtr *ptr)
_moo_ptr_ref (MooPtr *ptr)
{
if (ptr)
ptr->ref_count++;
@ -1757,7 +1753,7 @@ moo_ptr_ref (MooPtr *ptr)
void
moo_ptr_unref (MooPtr *ptr)
_moo_ptr_unref (MooPtr *ptr)
{
if (ptr && !--(ptr->ref_count))
{
@ -1769,14 +1765,14 @@ moo_ptr_unref (MooPtr *ptr)
GType
moo_data_get_type (void)
_moo_data_get_type (void)
{
static GType type = 0;
if (!type)
type = g_boxed_type_register_static ("MooData",
(GBoxedCopyFunc) moo_data_ref,
(GBoxedFreeFunc) moo_data_unref);
(GBoxedCopyFunc) _moo_data_ref,
(GBoxedFreeFunc) _moo_data_unref);
return type;
}
@ -1810,9 +1806,9 @@ copy_gvalue (const GValue *val)
MooData *
moo_data_new (GHashFunc hash_func,
GEqualFunc key_equal_func,
GDestroyNotify key_destroy_func)
_moo_data_new (GHashFunc hash_func,
GEqualFunc key_equal_func,
GDestroyNotify key_destroy_func)
{
MooData *data;
@ -1834,7 +1830,7 @@ moo_data_new (GHashFunc hash_func,
MooData *
moo_data_ref (MooData *data)
_moo_data_ref (MooData *data)
{
if (data)
data->ref_count++;
@ -1843,7 +1839,7 @@ moo_data_ref (MooData *data)
void
moo_data_unref (MooData *data)
_moo_data_unref (MooData *data)
{
if (data && !--(data->ref_count))
{
@ -1854,9 +1850,9 @@ moo_data_unref (MooData *data)
void
moo_data_insert_value (MooData *data,
gpointer key,
const GValue *value)
_moo_data_insert_value (MooData *data,
gpointer key,
const GValue *value)
{
g_return_if_fail (data != NULL);
g_return_if_fail (G_IS_VALUE (value));
@ -1865,10 +1861,10 @@ moo_data_insert_value (MooData *data,
void
moo_data_insert_ptr (MooData *data,
gpointer key,
gpointer value,
GDestroyNotify destroy)
_moo_data_insert_ptr (MooData *data,
gpointer key,
gpointer value,
GDestroyNotify destroy)
{
MooPtr *ptr;
GValue gval;
@ -1876,21 +1872,21 @@ moo_data_insert_ptr (MooData *data,
g_return_if_fail (data != NULL);
g_return_if_fail (value != NULL);
ptr = moo_ptr_new (value, destroy);
ptr = _moo_ptr_new (value, destroy);
gval.g_type = 0;
g_value_init (&gval, MOO_TYPE_PTR);
g_value_set_boxed (&gval, ptr);
moo_data_insert_value (data, key, &gval);
_moo_data_insert_value (data, key, &gval);
g_value_unset (&gval);
moo_ptr_unref (ptr);
_moo_ptr_unref (ptr);
}
void
moo_data_remove (MooData *data,
gpointer key)
_moo_data_remove (MooData *data,
gpointer key)
{
g_return_if_fail (data != NULL);
g_hash_table_remove (data->hash, key);
@ -1898,7 +1894,7 @@ moo_data_remove (MooData *data,
void
moo_data_clear (MooData *data)
_moo_data_clear (MooData *data)
{
g_return_if_fail (data != NULL);
@ -1912,7 +1908,7 @@ moo_data_clear (MooData *data)
guint
moo_data_size (MooData *data)
_moo_data_size (MooData *data)
{
g_return_val_if_fail (data != NULL, 0);
return g_hash_table_size (data->hash);
@ -1920,8 +1916,8 @@ moo_data_size (MooData *data)
gboolean
moo_data_has_key (MooData *data,
gpointer key)
_moo_data_has_key (MooData *data,
gpointer key)
{
g_return_val_if_fail (data != NULL, FALSE);
return g_hash_table_lookup (data->hash, key) != NULL;
@ -1929,8 +1925,8 @@ moo_data_has_key (MooData *data,
GType
moo_data_get_value_type (MooData *data,
gpointer key)
_moo_data_get_value_type (MooData *data,
gpointer key)
{
GValue *value;
g_return_val_if_fail (data != NULL, 0);
@ -1940,9 +1936,9 @@ moo_data_get_value_type (MooData *data,
gboolean
moo_data_get_value (MooData *data,
gpointer key,
GValue *dest)
_moo_data_get_value (MooData *data,
gpointer key,
GValue *dest)
{
GValue *value;
@ -1962,8 +1958,8 @@ moo_data_get_value (MooData *data,
gpointer
moo_data_get_ptr (MooData *data,
gpointer key)
_moo_data_get_ptr (MooData *data,
gpointer key)
{
MooPtr *ptr;
GValue *value;

218
moo/mooutils/mooutils-gobject.h
View File

@ -32,110 +32,42 @@ G_BEGIN_DECLS
/* GType type
*/
#define MOO_TYPE_GTYPE (moo_gtype_get_type())
#define MOO_TYPE_PARAM_GTYPE (moo_param_gtype_get_type())
#define MOO_IS_PARAM_SPEC_GTYPE(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), MOO_TYPE_PARAM_GTYPE))
#define MOO_PARAM_SPEC_GTYPE(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), MOO_TYPE_PARAM_GTYPE, MooParamSpecGType))
typedef struct _MooParamSpecGType MooParamSpecGType;
struct _MooParamSpecGType
{
GParamSpec parent;
GType base;
};
GType moo_gtype_get_type (void) G_GNUC_CONST;
GType moo_param_gtype_get_type (void) G_GNUC_CONST;
GParamSpec *moo_param_spec_gtype (const char *name,
const char *nick,
const char *blurb,
GType base,
GParamFlags flags);
void moo_value_set_gtype (GValue *value,
GType v_gtype);
GType moo_value_get_gtype (const GValue *value);
#define MOO_TYPE_GTYPE (_moo_gtype_get_type())
GType _moo_gtype_get_type (void) G_GNUC_CONST;
GType _moo_value_get_gtype (const GValue *value);
/*****************************************************************************/
/* Converting values forth and back
*/
gboolean moo_value_type_supported (GType type);
gboolean moo_value_convert (const GValue *src,
gboolean _moo_value_type_supported (GType type);
gboolean _moo_value_convert (const GValue *src,
GValue *dest);
gboolean moo_value_equal (const GValue *a,
gboolean _moo_value_equal (const GValue *a,
const GValue *b);
gboolean moo_value_change_type (GValue *val,
gboolean _moo_value_change_type (GValue *val,
GType new_type);
gboolean moo_value_convert_to_bool (const GValue *val);
int moo_value_convert_to_int (const GValue *val);
int moo_value_convert_to_enum (const GValue *val,
GType enum_type);
int moo_value_convert_to_flags (const GValue *val,
GType flags_type);
double moo_value_convert_to_double (const GValue *val);
const GdkColor *moo_value_convert_to_color (const GValue *val);
const char *moo_value_convert_to_string (const GValue *val);
gboolean moo_value_convert_from_string (const char *string,
double _moo_value_convert_to_double (const GValue *val);
const char *_moo_value_convert_to_string (const GValue *val);
gboolean _moo_value_convert_from_string (const char *string,
GValue *val);
gboolean moo_convert_string_to_bool (const char *string,
gboolean _moo_convert_string_to_bool (const char *string,
gboolean default_val);
int moo_convert_string_to_int (const char *string,
int _moo_convert_string_to_int (const char *string,
int default_val);
const char *moo_convert_bool_to_string (gboolean value);
const char *moo_convert_int_to_string (int value);
const char *_moo_convert_bool_to_string (gboolean value);
const char *_moo_convert_int_to_string (int value);
/*****************************************************************************/
/* GParameter array manipulation
*/
typedef GParamSpec* (*MooLookupProperty) (GObjectClass *klass,
const char *prop_name);
GParameter *moo_param_array_collect (GType type,
MooLookupProperty lookup_func,
guint *len,
const char *first_prop_name,
...) G_GNUC_NULL_TERMINATED;
GParameter *moo_param_array_collect_valist (GType type,
MooLookupProperty lookup_func,
guint *len,
const char *first_prop_name,
va_list var_args);
GParameter *moo_param_array_add (GType type,
GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
...) G_GNUC_NULL_TERMINATED;
GParameter *moo_param_array_add_valist (GType type,
GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
va_list var_args);
GParameter *moo_param_array_add_type (GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
...) G_GNUC_NULL_TERMINATED;
GParameter *moo_param_array_add_type_valist(GParameter *src,
guint len,
guint *new_len,
const char *first_prop_name,
va_list var_args);
void moo_param_array_free (GParameter *array,
void _moo_param_array_free (GParameter *array,
guint len);
@ -143,16 +75,16 @@ void moo_param_array_free (GParameter *array,
/* Signal that does not require class method
*/
guint moo_signal_new_cb (const gchar *signal_name,
GType itype,
GSignalFlags signal_flags,
GCallback handler,
GSignalAccumulator accumulator,
gpointer accu_data,
GSignalCMarshaller c_marshaller,
GType return_type,
guint n_params,
...);
guint _moo_signal_new_cb (const gchar *signal_name,
GType itype,
GSignalFlags signal_flags,
GCallback handler,
GSignalAccumulator accumulator,
gpointer accu_data,
GSignalCMarshaller c_marshaller,
GType return_type,
guint n_params,
...);
/*****************************************************************************/
@ -178,20 +110,14 @@ struct _MooObjectWatchClass {
MooObjectWatchNotify destroy;
};
MooObjectWatch *moo_object_watch_alloc (gsize size,
MooObjectWatchClass *klass,
gpointer source,
gpointer target,
GDestroyNotify notify,
gpointer notify_data);
#define moo_object_watch_new(Type_,klass_,src_,tgt_,notify_,data_) \
((Type_*) moo_object_watch_alloc (sizeof (Type_), klass_, src_, tgt_, notify_, data_))
guint moo_bind_signal (gpointer target,
const char *target_signal,
gpointer source,
const char *source_signal);
MooObjectWatch *_moo_object_watch_alloc (gsize size,
MooObjectWatchClass *klass,
gpointer source,
gpointer target,
GDestroyNotify notify,
gpointer notify_data);
#define _moo_object_watch_new(Type_,klass_,src_,tgt_,notify_,data_) \
((Type_*) _moo_object_watch_alloc (sizeof (Type_), klass_, src_, tgt_, notify_, data_))
void moo_bind_sensitive (GtkWidget *toggle_btn,
GtkWidget **dependent,
@ -203,98 +129,40 @@ guint moo_bind_bool_property (gpointer target,
gpointer source,
const char *source_prop,
gboolean invert);
gboolean moo_sync_bool_property (gpointer slave,
const char *slave_prop,
gpointer master,
const char *master_prop,
gboolean invert);
typedef void (*MooTransformPropFunc)(GValue *target,
const GValue *source,
gpointer data);
typedef void (*MooGetPropFunc) (GObject *source,
GValue *target,
gpointer data);
void moo_copy_boolean (GValue *target,
const GValue *source,
gpointer dummy);
void moo_invert_boolean (GValue *target,
const GValue *source,
gpointer dummy);
guint moo_add_property_watch (gpointer target,
const char *target_prop,
gpointer source,
const char *source_prop,
MooTransformPropFunc transform,
gpointer transform_data,
GDestroyNotify destroy_notify);
void moo_watch_add_signal (guint watch_id,
const char *source_signal);
void moo_watch_add_property (guint watch_id,
const char *source_prop);
gboolean moo_watch_remove (guint watch_id);
/*****************************************************************************/
/* Data store
*/
#define MOO_TYPE_PTR (moo_ptr_get_type ())
#define MOO_TYPE_DATA (moo_data_get_type ())
typedef struct _MooPtr MooPtr;
typedef struct _MooData MooData;
struct _MooPtr {
guint ref_count;
gpointer data;
GDestroyNotify free_func;
};
GType moo_ptr_get_type (void) G_GNUC_CONST;
GType moo_data_get_type (void) G_GNUC_CONST;
/* There are no ref-counted NULL pointers! */
MooPtr *moo_ptr_new (gpointer data,
GDestroyNotify free_func);
MooPtr *moo_ptr_ref (MooPtr *ptr);
void moo_ptr_unref (MooPtr *ptr);
MooData *moo_data_new (GHashFunc hash_func,
MooData *_moo_data_new (GHashFunc hash_func,
GEqualFunc key_equal_func,
GDestroyNotify key_destroy_func);
/* these accept NULL */
MooData *moo_data_ref (MooData *data);
void moo_data_unref (MooData *data);
#define moo_data_destroy moo_data_unref
MooData *_moo_data_ref (MooData *data);
void _moo_data_unref (MooData *data);
#define _moo_data_destroy _moo_data_unref
void moo_data_insert_value (MooData *data,
void _moo_data_insert_value (MooData *data,
gpointer key,
const GValue *value);
void moo_data_insert_ptr (MooData *data,
void _moo_data_insert_ptr (MooData *data,
gpointer key,
gpointer value,
GDestroyNotify destroy);
void moo_data_remove (MooData *data,
gpointer key);
void moo_data_clear (MooData *data);
guint moo_data_size (MooData *data);
gboolean moo_data_has_key (MooData *data,
gpointer key);
GType moo_data_get_value_type (MooData *data,
void _moo_data_remove (MooData *data,
gpointer key);
void _moo_data_clear (MooData *data);
/* dest must not be initialized */
gboolean moo_data_get_value (MooData *data,
gboolean _moo_data_get_value (MooData *data,
gpointer key,
GValue *dest);
gpointer moo_data_get_ptr (MooData *data,
gpointer _moo_data_get_ptr (MooData *data,
gpointer key);

5
moo/mooutils/moowindow.c
View File

@ -1295,7 +1295,7 @@ moo_window_class_new_actionv (MooWindowClass *klass,
goto error;
}
action_type = moo_value_get_gtype (&param.value);
action_type = _moo_value_get_gtype (&param.value);
if (!g_type_is_a (action_type, MOO_TYPE_ACTION_BASE))
{
@ -1379,8 +1379,7 @@ moo_window_class_new_actionv (MooWindowClass *klass,
goto error;
}
moo_param_array_free ((GParameter*) action_params->data,
action_params->len);
_moo_param_array_free ((GParameter*) action_params->data, action_params->len);
g_array_free (action_params, FALSE);
action_params = NULL;