void
gjs_gtk_container_child_set_property (GtkContainer *container,
GtkWidget *child,
const gchar *property,
const GValue *value)
{
GParamSpec *pspec;
pspec = gtk_container_class_find_child_property (G_OBJECT_GET_CLASS (container),
property);
if (pspec == NULL) {
g_warning ("%s does not have a property called %s",
g_type_name (G_OBJECT_TYPE (container)), property);
return;
}
if ((G_VALUE_TYPE (value) == G_TYPE_POINTER) &&
(g_value_get_pointer (value) == NULL) &&
!g_value_type_transformable (G_VALUE_TYPE (value), pspec->value_type)) {
/* Set an empty value. This will happen when we set a NULL value from JS.
* Since GJS doesn't know the GParamSpec for this property, it
* will just put NULL into a G_TYPE_POINTER GValue, which will later
* fail when trying to transform it to the GParamSpec's GType.
*/
GValue null_value = G_VALUE_INIT;
g_value_init (&null_value, pspec->value_type);
gtk_container_child_set_property (container, child,
property, &null_value);
g_value_unset (&null_value);
} else {
gtk_container_child_set_property (container, child,
property, value);
}
}
/**
* ppg_animation_update_child_property:
* @animation: (in): A #PpgAnimation.
* @target: (in): A #GObject.
* @tween: (in): A #Tween containing the property.
* @value: (in): The new value for the property.
*
* Updates the value of the parent widget of the target to @value.
*
* Returns: None.
* Side effects: The property of @target<!-- -->'s parent widget is updated.
*/
static void
ppg_animation_update_child_property (PpgAnimation *animation,
gpointer target,
Tween *tween,
const GValue *value)
{
GtkWidget *parent = gtk_widget_get_parent(GTK_WIDGET(target));
gtk_container_child_set_property(GTK_CONTAINER(parent), target,
tween->pspec->name, value);
}
void
glade_gtk_container_replace_child (GladeWidgetAdaptor * adaptor,
GtkWidget * container,
GtkWidget * current, GtkWidget * new_widget)
{
GParamSpec **param_spec;
GladePropertyClass *pclass;
GValue *value;
guint nproperties;
guint i;
g_return_if_fail (gtk_widget_get_parent (current) == container);
param_spec = gtk_container_class_list_child_properties
(G_OBJECT_GET_CLASS (container), &nproperties);
value = g_malloc0 (sizeof (GValue) * nproperties);
for (i = 0; i < nproperties; i++)
{
g_value_init (&value[i], param_spec[i]->value_type);
gtk_container_child_get_property
(GTK_CONTAINER (container), current, param_spec[i]->name, &value[i]);
}
gtk_container_remove (GTK_CONTAINER (container), current);
gtk_container_add (GTK_CONTAINER (container), new_widget);
for (i = 0; i < nproperties; i++)
{
/* If the added widget is a placeholder then we
* want to keep all the "tranfer-on-paste" properties
* as default so that it looks fresh (transfer-on-paste
* properties dont effect the position/slot inside a
* contianer)
*/
if (GLADE_IS_PLACEHOLDER (new_widget))
{
pclass = glade_widget_adaptor_get_pack_property_class
(adaptor, param_spec[i]->name);
if (pclass && glade_property_class_transfer_on_paste (pclass))
continue;
}
gtk_container_child_set_property
(GTK_CONTAINER (container), new_widget, param_spec[i]->name,
&value[i]);
}
for (i = 0; i < nproperties; i++)
g_value_unset (&value[i]);
g_free (param_spec);
g_free (value);
}
void
glade_gtk_container_set_child_property (GladeWidgetAdaptor * adaptor,
GObject * container,
GObject * child,
const gchar * property_name,
const GValue * value)
{
if (gtk_widget_get_parent (GTK_WIDGET (child)) == GTK_WIDGET (container))
gtk_container_child_set_property (GTK_CONTAINER (container),
GTK_WIDGET (child), property_name, value);
}
static void
set_property_value (GObject *object, GParamSpec *pspec, GValue *value)
{
if (is_child_property (pspec))
{
GtkWidget *widget = GTK_WIDGET (object);
GtkWidget *parent = gtk_widget_get_parent (widget);
gtk_container_child_set_property (GTK_CONTAINER (parent),
widget, pspec->name, value);
}
else
g_object_set_property (object, pspec->name, value);
}
void
container_set_child_property (GtkContainer *aParent,
GtkWidget *aChild,
const char *aProperty,
OOP aValue)
{
GParamSpec *spec;
GValue value = {0,};
g_return_if_fail (GTK_WIDGET (aParent) ==
gtk_widget_get_parent (GTK_WIDGET (aChild)));
spec = gtk_container_class_find_child_property (G_OBJECT_GET_CLASS (aParent),
aProperty);
g_value_init (&value, spec->value_type);
g_value_fill_from_oop (&value, aValue);
gtk_container_child_set_property (aParent, aChild, aProperty, &value);
}
static void
append_child_attrs_foreach (gpointer key, gpointer value, gpointer user_data)
{
if (!value) {
return;
}
GParamSpec *spec;
GError *error = NULL;
GValue gval = { 0 };
GtkWidget *child = GTK_WIDGET (user_data);
GtkWidget *parent = gtk_widget_get_parent (child);
spec = gtk_container_class_find_child_property (G_OBJECT_GET_CLASS (parent), (char *)key);
if (!spec ||
G_TYPE_FUNDAMENTAL (G_PARAM_SPEC_VALUE_TYPE (spec)) == G_TYPE_OBJECT) {
return;
}
#if 1
g_print ("found child property %s.%s on %s\n",
g_type_name (G_TYPE_FROM_INSTANCE (parent)),
spec->name,
g_type_name (G_TYPE_FROM_INSTANCE (child)));
#endif
if (gtk_builder_value_from_string (NULL, spec,
g_value_get_string ((const GValue *)value),
&gval, &error)) {
gtk_container_child_set_property (GTK_CONTAINER (parent), child,
spec->name, &gval);
g_value_unset (&gval);
} else {
g_print ("Error getting value_from_string: %s\n",
error->message);
g_error_free (error);
}
}
void
glade_gtk_header_bar_child_set_property (GladeWidgetAdaptor *adaptor,
GObject *container,
GObject *child,
const gchar *property_name,
const GValue *value)
{
GladeWidget *gbox;
gint size;
d(g_message ("Set child prop %s %s\n", g_type_name_from_instance (child), property_name));
gtk_container_child_set_property (GTK_CONTAINER (container),
GTK_WIDGET (child),
property_name,
value);
gbox = glade_widget_get_from_gobject (container);
if (!glade_widget_superuser ())
{
glade_widget_property_get (gbox, "size", &size);
glade_widget_property_set (gbox, "size", size);
}
}
static void
af_transition_set_progress (AfTransition *transition,
gdouble progress,
gpointer user_data)
{
GValue value = { 0, };
GArray *properties;
guint i;
AfTypeTransformationFunc func;
properties = transition->properties;
progress = af_timeline_calculate_progress (progress, transition->type);
for (i = 0; i < properties->len; i++)
{
AfPropertyRange *property_range;
gboolean handled = FALSE;
GType type;
property_range = &g_array_index (properties, AfPropertyRange, i);
if (G_UNLIKELY (G_VALUE_TYPE (&property_range->from) == G_TYPE_INVALID))
{
g_value_init (&property_range->from,
property_range->pspec->value_type);
if (!transition->child)
g_object_get_property (transition->object,
property_range->pspec->name,
&property_range->from);
else
gtk_container_child_get_property (GTK_CONTAINER (transition->object),
GTK_WIDGET (transition->child),
property_range->pspec->name,
&property_range->from);
}
g_value_init (&value, property_range->pspec->value_type);
type = property_range->pspec->value_type;
func = transition->func;
if (!func && transformable_types)
func = g_hash_table_lookup (transformable_types, GSIZE_TO_POINTER (type));
if (!func)
{
switch (type)
{
case G_TYPE_INT:
{
gint from, to, val;
from = g_value_get_int (&property_range->from);
to = g_value_get_int (&property_range->to);
val = from + ((to - from) * progress);
g_value_set_int (&value, val);
handled = TRUE;
}
break;
case G_TYPE_DOUBLE:
{
gdouble from, to, val;
from = g_value_get_double (&property_range->from);
to = g_value_get_double (&property_range->to);
val = from + ((to - from) * progress);
g_value_set_double (&value, val);
handled = TRUE;
}
break;
case G_TYPE_FLOAT:
{
gfloat from, to, val;
from = g_value_get_float (&property_range->from);
to = g_value_get_float (&property_range->to);
val = from + ((to - from) * progress);
g_value_set_float (&value, val);
handled = TRUE;
}
break;
default:
g_warning ("Property of type '%s' not handled", g_type_name (type));
}
}
else
{
(func) (&property_range->from,
&property_range->to,
progress,
user_data,
&value);
handled = TRUE;
}
if (handled)
{
if (!transition->child)
g_object_set_property (transition->object,
property_range->pspec->name,
&value);
else
gtk_container_child_set_property (GTK_CONTAINER (transition->object),
GTK_WIDGET (transition->child),
property_range->pspec->name,
&value);
}
g_value_unset (&value);
}
}
/**
* Construct (or reconstruct when settings change) the window's paned layout
*
* It is worth noting that the string preferences only use the first character
* to determine orientation since they are all unique (and it avoids calling
* extra string functions). The full strings are just for readable prefs.xml.
*
* @param[in] gtkblist The Buddy List that needs a new paned window structure
* @param[in] side The pref where convs are placed relative to the blist
*
* @note This is structured to default to "right" on an invalid pref setting.
**/
void pwm_create_paned_layout(PidginBuddyList *gtkblist, const char *side)
{
PidginWindow *
gtkconvwin; /*< Conversation window merged into gtkblist */
GtkWidget *old_paned; /*< The existing paned layout, if it exists */
GtkWidget *paned; /*< The new layout panes being created */
GtkWidget *placeholder; /*< Marks the conv notebook's original spot */
GValue value =
G_VALUE_INIT; /*< For passing a property value to a widget */
gtkconvwin = pwm_blist_get_convs(gtkblist);
old_paned = pwm_fetch(gtkblist, "paned");
/* Create the requested vertical or horizontal paned layout. */
if (side != NULL && (*side == 't' || *side == 'b'))
paned = gtk_vpaned_new();
else
paned = gtk_hpaned_new();
gtk_widget_show(paned);
pwm_store(gtkblist, "paned", paned);
/* When the size of the panes is determined, reset the Buddy List size.
*/
g_object_connect(G_OBJECT(paned), "signal::notify::max-position",
G_CALLBACK(notify_max_position_cb), gtkblist, NULL);
/* If the Buddy List is pristine, make the panes and replace its
* notebook. */
if (old_paned == NULL) {
placeholder = gtk_label_new(NULL);
if (side != NULL && (*side == 't' || *side == 'l')) {
pwm_widget_replace(gtkconvwin->notebook, placeholder,
paned);
pwm_widget_replace(gtkblist->notebook, paned, paned);
} else {
pwm_widget_replace(gtkblist->notebook, paned, paned);
pwm_widget_replace(gtkconvwin->notebook, placeholder,
paned);
}
pwm_store(gtkblist, "placeholder", placeholder);
}
/* If existing panes are being replaced, define the new layout and use
it. */
else {
if (side != NULL && (*side == 't' || *side == 'l')) {
gtk_widget_reparent(gtkconvwin->notebook, paned);
gtk_widget_reparent(gtkblist->notebook, paned);
} else {
gtk_widget_reparent(gtkblist->notebook, paned);
gtk_widget_reparent(gtkconvwin->notebook, paned);
}
pwm_widget_replace(old_paned, paned, NULL);
}
/* Make conversations resize with the window so the Buddy List is fixed.
*/
g_value_init(&value, G_TYPE_BOOLEAN);
g_value_set_boolean(&value, TRUE);
gtk_container_child_set_property(
GTK_CONTAINER(paned), gtkconvwin->notebook, "resize", &value);
g_value_set_boolean(&value, FALSE);
gtk_container_child_set_property(GTK_CONTAINER(paned),
gtkblist->notebook, "resize", &value);
}
void termit_append_tab_with_details(const struct TabInfo* ti)
{
struct TermitTab* pTab = g_malloc0(sizeof(struct TermitTab));
termit_style_copy(&pTab->style, &configs.style);
if (ti->name) {
pTab->tab_name = gtk_label_new(ti->name);
pTab->custom_tab_name = TRUE;
} else {
gchar* label_text = g_strdup_printf("%s %d", configs.default_tab_name, termit.tab_max_number++);
pTab->tab_name = gtk_label_new(label_text);
g_free(label_text);
pTab->custom_tab_name = FALSE;
}
pTab->encoding = (ti->encoding) ? g_strdup(ti->encoding) : g_strdup(configs.default_encoding);
pTab->bksp_binding = ti->bksp_binding;
pTab->delete_binding = ti->delete_binding;
pTab->hbox = gtk_hbox_new(FALSE, 0);
pTab->vte = vte_terminal_new();
vte_terminal_set_scrollback_lines(VTE_TERMINAL(pTab->vte), configs.scrollback_lines);
if (configs.default_word_chars)
vte_terminal_set_word_chars(VTE_TERMINAL(pTab->vte), configs.default_word_chars);
vte_terminal_set_mouse_autohide(VTE_TERMINAL(pTab->vte), TRUE);
vte_terminal_set_backspace_binding(VTE_TERMINAL(pTab->vte), pTab->bksp_binding);
vte_terminal_set_delete_binding(VTE_TERMINAL(pTab->vte), pTab->delete_binding);
#ifdef TERMIT_ENABLE_SEARCH
vte_terminal_search_set_wrap_around(VTE_TERMINAL(pTab->vte), TRUE);
#endif // TERMIT_ENABLE_SEARCH
/* parse command */
gchar **cmd_argv;
GError *cmd_err = NULL;
gchar *cmd_path = NULL;
gchar *cmd_file = NULL;
pTab->command = (ti->command) ? g_strdup(ti->command) : g_strdup(configs.default_command);
if (!g_shell_parse_argv(pTab->command, NULL, &cmd_argv, &cmd_err)) {
ERROR("%s", _("Cannot parse command. Creating tab with shell"));
g_error_free(cmd_err);
} else {
cmd_path = g_find_program_in_path(cmd_argv[0]);
cmd_file = g_path_get_basename(cmd_argv[0]);
}
TRACE("command=%s cmd_path=%s cmd_file=%s", pTab->command, cmd_path, cmd_file);
if (cmd_path && cmd_file) {
g_free(cmd_argv[0]);
cmd_argv[0] = g_strdup(cmd_path);
#if VTE_CHECK_VERSION(0, 26, 0) > 0
if (vte_terminal_fork_command_full(VTE_TERMINAL(pTab->vte),
VTE_PTY_DEFAULT,
ti->working_dir,
cmd_argv, NULL,
0,
NULL, NULL,
&pTab->pid,
&cmd_err) != TRUE) {
ERROR("failed to open tab: %s", cmd_err->message);
g_error_free(cmd_err);
}
#else
pTab->pid = vte_terminal_fork_command(VTE_TERMINAL(pTab->vte),
cmd_path, cmd_argv, NULL, ti->working_dir, TRUE, TRUE, TRUE);
#endif // version >= 0.26
} else {
g_free(pTab->command);
pTab->command = g_strdup(configs.default_command);
gchar* argv[] = {pTab->command, NULL};
TRACE("defaults: cmd=%s working_dir=%s", pTab->command, ti->working_dir);
/* default tab */
#if VTE_CHECK_VERSION(0, 26, 0) > 0
if (vte_terminal_fork_command_full(VTE_TERMINAL(pTab->vte),
VTE_PTY_DEFAULT,
ti->working_dir,
argv, NULL,
G_SPAWN_SEARCH_PATH,
NULL, NULL,
&pTab->pid,
&cmd_err) != TRUE) {
ERROR("failed to open tab: %s", cmd_err->message);
g_error_free(cmd_err);
}
#else
pTab->pid = vte_terminal_fork_command(VTE_TERMINAL(pTab->vte),
pTab->command, NULL, NULL, ti->working_dir, TRUE, TRUE, TRUE);
#endif // version >= 0.26
}
g_strfreev(cmd_argv);
g_free(cmd_path);
g_free(cmd_file);
g_signal_connect(G_OBJECT(pTab->vte), "beep", G_CALLBACK(termit_on_beep), pTab);
g_signal_connect(G_OBJECT(pTab->vte), "focus-in-event", G_CALLBACK(termit_on_focus), pTab);
g_signal_connect(G_OBJECT(pTab->vte), "window-title-changed", G_CALLBACK(termit_on_tab_title_changed), NULL);
g_signal_connect(G_OBJECT(pTab->vte), "child-exited", G_CALLBACK(termit_on_child_exited), NULL);
// g_signal_connect(G_OBJECT(pTab->vte), "eof", G_CALLBACK(termit_eof), NULL);
g_signal_connect_swapped(G_OBJECT(pTab->vte), "button-press-event", G_CALLBACK(termit_on_popup), NULL);
vte_terminal_set_encoding(VTE_TERMINAL(pTab->vte), pTab->encoding);
pTab->matches = g_array_new(FALSE, TRUE, sizeof(struct Match));
termit_tab_add_matches(pTab, configs.matches);
termit_tab_set_transparency(pTab, pTab->style.transparency);
vte_terminal_set_font(VTE_TERMINAL(pTab->vte), pTab->style.font);
gint index = gtk_notebook_append_page(GTK_NOTEBOOK(termit.notebook), pTab->hbox, pTab->tab_name);
if (index == -1) {
ERROR("%s", _("Cannot create a new tab"));
return;
}
if (configs.fill_tabbar) {
GValue val = {};
g_value_init(&val, G_TYPE_BOOLEAN);
g_value_set_boolean(&val, TRUE);
gtk_container_child_set_property(GTK_CONTAINER(termit.notebook), pTab->hbox, "tab-expand", &val);
gtk_container_child_set_property(GTK_CONTAINER(termit.notebook), pTab->hbox, "tab-fill", &val);
}
termit_tab_set_audible_bell(pTab, configs.audible_bell);
termit_tab_set_visible_bell(pTab, configs.visible_bell);
pTab->scrollbar = gtk_vscrollbar_new(vte_terminal_get_adjustment(VTE_TERMINAL(pTab->vte)));
gtk_box_pack_start(GTK_BOX(pTab->hbox), pTab->vte, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(pTab->hbox), pTab->scrollbar, FALSE, FALSE, 0);
GtkWidget* tabWidget = gtk_notebook_get_nth_page(GTK_NOTEBOOK(termit.notebook), index);
if (!tabWidget) {
ERROR("tabWidget is NULL");
return;
}
g_object_set_data(G_OBJECT(tabWidget), TERMIT_TAB_DATA, pTab);
if (index == 0) { // there is no "switch-page" signal on the first page
termit_set_statusbar_message(index);
}
pTab->scrollbar_is_shown = configs.show_scrollbar;
gtk_widget_show_all(termit.notebook);
if (pTab->style.image_file == NULL) {
vte_terminal_set_background_image(VTE_TERMINAL(pTab->vte), NULL);
} else {
vte_terminal_set_background_image_file(VTE_TERMINAL(pTab->vte), pTab->style.image_file);
}
termit_tab_apply_colors(pTab);
gtk_notebook_set_current_page(GTK_NOTEBOOK(termit.notebook), index);
gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(termit.notebook), pTab->hbox, TRUE);
gtk_window_set_focus(GTK_WINDOW(termit.main_window), pTab->vte);
termit_check_single_tab();
termit_hide_scrollbars();
}
void child_set_property(Gtk::Container& container, Gtk::Widget& child, const char *property_name, bool value) {
GValue v = {0};
g_value_init(&v, G_TYPE_BOOLEAN);
g_value_set_boolean(&v, value);
gtk_container_child_set_property(container.gobj(), child.gobj(), property_name, &v);
}
