pidgin/pidgin
Clone
Summary
Browse
Changes
Graph
Fix various small documentation errors
19 months ago, Elliott Sales de Andrade
316c1207f787
Fix various small documentation errors
Fix missing transfer annotations, remove old syntax from gtk-doc, correct an `element-type` annotation, and fix a typo.
Testing Done:
Compiled with docs on, and got fewer warnings. Also functions with added transfer annotations are no longer unavailable to bindings.
Reviewed at https://reviews.imfreedom.org/r/1855/
/*
* Pidgin - Internet Messenger
* Copyright (C) Pidgin Developers <devel@pidgin.im>
*
* Pidgin is the legal property of its developers, whose names are too numerous
* to list here. Please refer to the COPYRIGHT file distributed with this
* source distribution.
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see <https://www.gnu.org/licenses/>.
*/
#include
<glib/gi18n-lib.h>
#include
<adwaita.h>
#include
"pidginaccounteditor.h"
#include
"pidginprotocolchooser.h"
struct
_PidginAccountEditor
{
GtkDialog
parent
;
PurpleAccount
*
account
;
/* Login Options */
GtkWidget
*
login_options
;
GtkWidget
*
protocol
;
GtkWidget
*
username
;
GList
*
user_split_entries
;
GList
*
user_split_rows
;
/* User Options */
GtkWidget
*
alias
;
GtkFileChooserNative
*
avatar_dialog
;
GdkPixbuf
*
avatar_pixbuf
;
GtkWidget
*
avatar_row
;
GtkWidget
*
use_custom_avatar
;
GtkWidget
*
avatar
;
/* Advanced Options */
GtkWidget
*
advanced_group
;
GtkWidget
*
advanced_toggle
;
GList
*
advanced_entries
;
GList
*
advanced_rows
;
/* Proxy Options */
GtkWidget
*
proxy_type
;
GtkWidget
*
proxy_options
;
GtkWidget
*
proxy_host
;
GtkWidget
*
proxy_port
;
GtkWidget
*
proxy_username
;
GtkWidget
*
proxy_password
;
};
enum
{
PROP_0
,
PROP_ACCOUNT
,
N_PROPERTIES
,
};
static
GParamSpec
*
properties
[
N_PROPERTIES
]
=
{
NULL
,
};
/******************************************************************************
* Prototypes
*****************************************************************************/
static
void
pidgin_account_editor_connection_changed_cb
(
GObject
*
obj
,
GParamSpec
*
pspec
,
gpointer
data
);
/******************************************************************************
* Helpers
*****************************************************************************/
static
void
pidgin_account_editor_add_user_split
(
gpointer
data
,
gpointer
user_data
)
{
PurpleAccountUserSplit
*
split
=
data
;
PidginAccountEditor
*
editor
=
user_data
;
GtkWidget
*
entry
=
NULL
;
if
(
!
purple_account_user_split_is_constant
(
split
))
{
GtkWidget
*
row
=
NULL
;
row
=
adw_action_row_new
();
editor
->
user_split_rows
=
g_list_append
(
editor
->
user_split_rows
,
row
);
adw_preferences_group_add
(
ADW_PREFERENCES_GROUP
(
editor
->
login_options
),
row
);
adw_preferences_row_set_title
(
ADW_PREFERENCES_ROW
(
row
),
purple_account_user_split_get_text
(
split
));
entry
=
gtk_entry_new
();
gtk_widget_set_hexpand
(
entry
,
TRUE
);
gtk_widget_set_valign
(
entry
,
GTK_ALIGN_CENTER
);
adw_action_row_add_suffix
(
ADW_ACTION_ROW
(
row
),
entry
);
adw_action_row_set_activatable_widget
(
ADW_ACTION_ROW
(
row
),
entry
);
}
editor
->
user_split_entries
=
g_list_append
(
editor
->
user_split_entries
,
entry
);
}
static
gboolean
pidgin_account_editor_update_login_options
(
PidginAccountEditor
*
editor
,
PurpleProtocol
*
protocol
)
{
GList
*
user_splits
=
NULL
;
GList
*
split_item
=
NULL
;
GList
*
entry_item
=
NULL
;
gchar
*
username
=
NULL
;
/* Clear out the old user splits from our list. */
g_clear_pointer
(
&
editor
->
user_split_entries
,
g_list_free
);
/* Now remove the rows we added to the preference group for each non
* constant user split.
*/
while
(
editor
->
user_split_rows
!=
NULL
)
{
adw_preferences_group_remove
(
ADW_PREFERENCES_GROUP
(
editor
->
login_options
),
editor
->
user_split_rows
->
data
);
editor
->
user_split_rows
=
g_list_delete_link
(
editor
->
user_split_rows
,
editor
->
user_split_rows
);
}
/* Add the user splits for the protocol. */
user_splits
=
purple_protocol_get_user_splits
(
protocol
);
g_list_foreach
(
user_splits
,
pidgin_account_editor_add_user_split
,
editor
);
/* If we have an account, populate its values. */
if
(
PURPLE_IS_ACCOUNT
(
editor
->
account
))
{
/* The username will be split apart below and eventually set as the text
* in the username entry.
*/
username
=
g_strdup
(
purple_account_get_username
(
editor
->
account
));
}
/* Filling out the user splits is a pain. If we have an account, we created
* a copy of the username above. We then iterate the user splits backwards
* so we can insert a null terminator at the start of each split we find in
* the username.
*/
split_item
=
g_list_last
(
user_splits
);
entry_item
=
g_list_last
(
editor
->
user_split_entries
);
while
(
split_item
!=
NULL
&&
entry_item
!=
NULL
)
{
GtkWidget
*
entry
=
entry_item
->
data
;
PurpleAccountUserSplit
*
split
=
split_item
->
data
;
gchar
*
ptr
=
NULL
;
const
gchar
*
value
=
NULL
;
if
(
username
!=
NULL
)
{
gchar
sep
=
purple_account_user_split_get_separator
(
split
);
if
(
purple_account_user_split_get_reverse
(
split
))
{
ptr
=
strrchr
(
username
,
sep
);
}
else
{
ptr
=
strchr
(
username
,
sep
);
}
if
(
ptr
!=
NULL
)
{
/* Insert a null terminator in place of the separator. */
*
ptr
=
'\0'
;
/* Set the value to the first byte after the separator. */
value
=
ptr
+
1
;
}
}
if
(
value
==
NULL
)
{
value
=
purple_account_user_split_get_default_value
(
split
);
}
if
(
value
!=
NULL
&&
GTK_IS_ENTRY
(
entry
))
{
gtk_editable_set_text
(
GTK_EDITABLE
(
entry
),
value
);
}
split_item
=
split_item
->
prev
;
entry_item
=
entry_item
->
prev
;
}
/* Free the user splits. */
g_list_free_full
(
user_splits
,
(
GDestroyNotify
)
purple_account_user_split_destroy
);
/* Set the username entry to the remaining text in username and free our
* copy of said username.
*/
if
(
username
!=
NULL
)
{
gtk_editable_set_text
(
GTK_EDITABLE
(
editor
->
username
),
username
);
g_free
(
username
);
return
TRUE
;
}
return
FALSE
;
}
static
void
pidgin_account_editor_update_user_options
(
PidginAccountEditor
*
editor
,
PurpleProtocol
*
protocol
)
{
PurpleBuddyIconSpec
*
icon_spec
=
NULL
;
PurpleImage
*
image
=
NULL
;
gboolean
show_avatar_opts
=
TRUE
;
const
gchar
*
svalue
=
""
;
gboolean
use_global
=
TRUE
;
/* Check if the protocol supports avatars. */
icon_spec
=
purple_protocol_get_icon_spec
(
protocol
);
show_avatar_opts
=
(
icon_spec
!=
NULL
&&
icon_spec
->
format
!=
NULL
);
purple_buddy_icon_spec_free
(
icon_spec
);
gtk_widget_set_visible
(
editor
->
avatar_row
,
show_avatar_opts
);
/* Determine our values. */
if
(
editor
->
account
!=
NULL
)
{
svalue
=
purple_account_get_private_alias
(
editor
->
account
);
image
=
purple_buddy_icons_find_account_icon
(
editor
->
account
);
use_global
=
purple_account_get_bool
(
editor
->
account
,
"use-global-buddyicon"
,
TRUE
);
}
if
(
svalue
==
NULL
)
{
svalue
=
""
;
}
gtk_editable_set_text
(
GTK_EDITABLE
(
editor
->
alias
),
svalue
);
gtk_switch_set_active
(
GTK_SWITCH
(
editor
->
use_custom_avatar
),
!
use_global
);
g_clear_object
(
&
editor
->
avatar_pixbuf
);
if
(
PURPLE_IS_IMAGE
(
image
))
{
editor
->
avatar_pixbuf
=
purple_gdk_pixbuf_from_image
(
image
);
gtk_image_set_from_pixbuf
(
GTK_IMAGE
(
editor
->
avatar
),
editor
->
avatar_pixbuf
);
}
else
{
gtk_image_set_from_icon_name
(
GTK_IMAGE
(
editor
->
avatar
),
"select-avatar"
);
}
}
static
gboolean
pidgin_account_editor_advanced_option_use_default
(
PidginAccountEditor
*
editor
)
{
PurpleProtocol
*
protocol
=
NULL
;
/* If this is the new dialog, use the default value. */
if
(
!
PURPLE_IS_ACCOUNT
(
editor
->
account
))
{
return
TRUE
;
}
/* If we have an existing account, check if the protocol has changed. */
protocol
=
pidgin_protocol_chooser_get_protocol
(
PIDGIN_PROTOCOL_CHOOSER
(
editor
->
protocol
));
if
(
protocol
!=
purple_account_get_protocol
(
editor
->
account
))
{
return
TRUE
;
}
return
FALSE
;
}
static
GtkWidget
*
pidgin_account_editor_add_advanced_boolean
(
PidginAccountEditor
*
editor
,
PurpleAccountOption
*
option
)
{
GtkWidget
*
row
=
NULL
;
GtkWidget
*
toggle
=
NULL
;
gboolean
value
=
FALSE
;
gchar
*
title
=
NULL
;
if
(
pidgin_account_editor_advanced_option_use_default
(
editor
))
{
value
=
purple_account_option_get_default_bool
(
option
);
}
else
{
const
gchar
*
setting
=
purple_account_option_get_setting
(
option
);
gboolean
def_value
=
purple_account_option_get_default_bool
(
option
);
value
=
purple_account_get_bool
(
editor
->
account
,
setting
,
def_value
);
}
/* Create the row and set its title with a mnemonic. */
row
=
adw_action_row_new
();
g_object_bind_property
(
editor
->
advanced_toggle
,
"active"
,
row
,
"visible"
,
G_BINDING_SYNC_CREATE
);
adw_preferences_row_set_use_underline
(
ADW_PREFERENCES_ROW
(
row
),
TRUE
);
title
=
g_strdup_printf
(
"_%s"
,
purple_account_option_get_text
(
option
));
adw_preferences_row_set_title
(
ADW_PREFERENCES_ROW
(
row
),
title
);
g_free
(
title
);
adw_preferences_group_add
(
ADW_PREFERENCES_GROUP
(
editor
->
advanced_group
),
row
);
/* Add the row to the editor's list of advanced rows. */
editor
->
advanced_rows
=
g_list_append
(
editor
->
advanced_rows
,
row
);
/* Create the input widget. */
toggle
=
gtk_switch_new
();
gtk_switch_set_active
(
GTK_SWITCH
(
toggle
),
value
);
gtk_widget_set_valign
(
toggle
,
GTK_ALIGN_CENTER
);
adw_action_row_add_suffix
(
ADW_ACTION_ROW
(
row
),
toggle
);
adw_action_row_set_activatable_widget
(
ADW_ACTION_ROW
(
row
),
toggle
);
return
toggle
;
}
static
GtkWidget
*
pidgin_account_editor_add_advanced_int
(
PidginAccountEditor
*
editor
,
PurpleAccountOption
*
option
)
{
GtkWidget
*
row
=
NULL
;
GtkWidget
*
entry
=
NULL
;
gint
value
=
0
;
gchar
*
title
=
NULL
;
gchar
*
svalue
=
NULL
;
if
(
pidgin_account_editor_advanced_option_use_default
(
editor
))
{
value
=
purple_account_option_get_default_int
(
option
);
}
else
{
const
gchar
*
setting
=
purple_account_option_get_setting
(
option
);
gint
def_value
=
purple_account_option_get_default_int
(
option
);
value
=
purple_account_get_int
(
editor
->
account
,
setting
,
def_value
);
}
/* Create the row and set its title with a mnemonic. */
row
=
adw_action_row_new
();
g_object_bind_property
(
editor
->
advanced_toggle
,
"active"
,
row
,
"visible"
,
G_BINDING_SYNC_CREATE
);
adw_preferences_row_set_use_underline
(
ADW_PREFERENCES_ROW
(
row
),
TRUE
);
title
=
g_strdup_printf
(
"_%s"
,
purple_account_option_get_text
(
option
));
adw_preferences_row_set_title
(
ADW_PREFERENCES_ROW
(
row
),
title
);
g_free
(
title
);
adw_preferences_group_add
(
ADW_PREFERENCES_GROUP
(
editor
->
advanced_group
),
row
);
/* Add the row to the editor's list of advanced rows. */
editor
->
advanced_rows
=
g_list_append
(
editor
->
advanced_rows
,
row
);
/* Create the input widget. */
entry
=
gtk_entry_new
();
gtk_entry_set_input_purpose
(
GTK_ENTRY
(
entry
),
GTK_INPUT_PURPOSE_DIGITS
);
svalue
=
g_strdup_printf
(
"%d"
,
value
);
gtk_editable_set_text
(
GTK_EDITABLE
(
entry
),
svalue
);
g_free
(
svalue
);
gtk_widget_set_hexpand
(
entry
,
TRUE
);
gtk_widget_set_valign
(
entry
,
GTK_ALIGN_CENTER
);
adw_action_row_add_suffix
(
ADW_ACTION_ROW
(
row
),
entry
);
adw_action_row_set_activatable_widget
(
ADW_ACTION_ROW
(
row
),
entry
);
return
entry
;
}
static
GtkWidget
*
pidgin_account_editor_add_advanced_string
(
PidginAccountEditor
*
editor
,
PurpleAccountOption
*
option
)
{
GtkWidget
*
row
=
NULL
;
GtkWidget
*
entry
=
NULL
;
gchar
*
title
=
NULL
;
const
gchar
*
value
=
NULL
;
if
(
pidgin_account_editor_advanced_option_use_default
(
editor
))
{
value
=
purple_account_option_get_default_string
(
option
);
}
else
{
const
gchar
*
setting
=
purple_account_option_get_setting
(
option
);
const
gchar
*
def_value
=
NULL
;
def_value
=
purple_account_option_get_default_string
(
option
);
value
=
purple_account_get_string
(
editor
->
account
,
setting
,
def_value
);
}
/* Create the row and set its title with a mnemonic. */
row
=
adw_action_row_new
();
g_object_bind_property
(
editor
->
advanced_toggle
,
"active"
,
row
,
"visible"
,
G_BINDING_SYNC_CREATE
);
adw_preferences_row_set_use_underline
(
ADW_PREFERENCES_ROW
(
row
),
TRUE
);
title
=
g_strdup_printf
(
"_%s"
,
purple_account_option_get_text
(
option
));
adw_preferences_row_set_title
(
ADW_PREFERENCES_ROW
(
row
),
title
);
g_free
(
title
);
adw_preferences_group_add
(
ADW_PREFERENCES_GROUP
(
editor
->
advanced_group
),
row
);
/* Add the row to the editor's list of advanced rows. */
editor
->
advanced_rows
=
g_list_append
(
editor
->
advanced_rows
,
row
);
/* Create the input widget. */
if
(
purple_account_option_string_get_masked
(
option
))
{
entry
=
gtk_password_entry_new
();
}
else
{
entry
=
gtk_entry_new
();
}
if
(
value
!=
NULL
)
{
gtk_editable_set_text
(
GTK_EDITABLE
(
entry
),
value
);
}
gtk_widget_set_hexpand
(
entry
,
TRUE
);
gtk_widget_set_valign
(
entry
,
GTK_ALIGN_CENTER
);
adw_action_row_add_suffix
(
ADW_ACTION_ROW
(
row
),
entry
);
adw_action_row_set_activatable_widget
(
ADW_ACTION_ROW
(
row
),
entry
);
return
entry
;
}
static
GtkWidget
*
pidgin_account_editor_add_advanced_list
(
PidginAccountEditor
*
editor
,
PurpleAccountOption
*
option
)
{
GtkWidget
*
row
=
NULL
;
GtkStringList
*
model
=
NULL
;
GList
*
data
=
NULL
;
GList
*
items
=
NULL
;
gchar
*
title
=
NULL
;
const
gchar
*
value
=
FALSE
;
guint
index
=
0
;
guint
position
=
0
;
if
(
pidgin_account_editor_advanced_option_use_default
(
editor
))
{
value
=
purple_account_option_get_default_list_value
(
option
);
}
else
{
const
gchar
*
setting
=
purple_account_option_get_setting
(
option
);
const
gchar
*
def_value
=
NULL
;
def_value
=
purple_account_option_get_default_list_value
(
option
);
value
=
purple_account_get_string
(
editor
->
account
,
setting
,
def_value
);
}
/* Create the row and set its title with a mnemonic. */
row
=
adw_combo_row_new
();
g_object_bind_property
(
editor
->
advanced_toggle
,
"active"
,
row
,
"visible"
,
G_BINDING_SYNC_CREATE
);
adw_preferences_row_set_use_underline
(
ADW_PREFERENCES_ROW
(
row
),
TRUE
);
adw_combo_row_set_use_subtitle
(
ADW_COMBO_ROW
(
row
),
TRUE
);
title
=
g_strdup_printf
(
"_%s"
,
purple_account_option_get_text
(
option
));
adw_preferences_row_set_title
(
ADW_PREFERENCES_ROW
(
row
),
title
);
g_free
(
title
);
adw_preferences_group_add
(
ADW_PREFERENCES_GROUP
(
editor
->
advanced_group
),
row
);
/* Add the row to the editor's list of advanced rows. */
editor
->
advanced_rows
=
g_list_append
(
editor
->
advanced_rows
,
row
);
/* Create the model and data for the expression. */
items
=
purple_account_option_get_list
(
option
);
model
=
gtk_string_list_new
(
NULL
);
for
(
GList
*
l
=
items
;
l
!=
NULL
;
l
=
l
->
next
)
{
PurpleKeyValuePair
*
kvp
=
l
->
data
;
if
(
kvp
!=
NULL
)
{
if
(
purple_strequal
(
kvp
->
value
,
value
))
{
position
=
index
;
}
data
=
g_list_append
(
data
,
kvp
->
value
);
gtk_string_list_append
(
model
,
kvp
->
key
);
}
index
++
;
}
adw_combo_row_set_model
(
ADW_COMBO_ROW
(
row
),
G_LIST_MODEL
(
model
));
adw_combo_row_set_selected
(
ADW_COMBO_ROW
(
row
),
position
);
g_object_set_data_full
(
G_OBJECT
(
row
),
"keys"
,
data
,
(
GDestroyNotify
)
g_list_free
);
return
row
;
}
static
void
pidgin_account_editor_add_advanced_option
(
PidginAccountEditor
*
editor
,
PurpleAccountOption
*
option
)
{
PurplePrefType
type
;
GtkWidget
*
widget
=
NULL
;
type
=
purple_account_option_get_pref_type
(
option
);
switch
(
type
)
{
case
PURPLE_PREF_BOOLEAN
:
widget
=
pidgin_account_editor_add_advanced_boolean
(
editor
,
option
);
break
;
case
PURPLE_PREF_INT
:
widget
=
pidgin_account_editor_add_advanced_int
(
editor
,
option
);
break
;
case
PURPLE_PREF_STRING
:
widget
=
pidgin_account_editor_add_advanced_string
(
editor
,
option
);
break
;
case
PURPLE_PREF_STRING_LIST
:
widget
=
pidgin_account_editor_add_advanced_list
(
editor
,
option
);
break
;
default
:
purple_debug_error
(
"PidginAccountEditor"
,
"Invalid Account Option pref type (%d)"
,
type
);
break
;
}
if
(
GTK_IS_WIDGET
(
widget
))
{
g_object_set_data_full
(
G_OBJECT
(
widget
),
"option"
,
option
,
(
GDestroyNotify
)
purple_account_option_destroy
);
editor
->
advanced_entries
=
g_list_append
(
editor
->
advanced_entries
,
widget
);
}
else
{
purple_account_option_destroy
(
option
);
}
}
static
void
pidgin_account_editor_update_advanced_options
(
PidginAccountEditor
*
editor
,
PurpleProtocol
*
protocol
)
{
GList
*
options
=
NULL
;
g_clear_pointer
(
&
editor
->
advanced_entries
,
g_list_free
);
while
(
editor
->
advanced_rows
!=
NULL
)
{
adw_preferences_group_remove
(
ADW_PREFERENCES_GROUP
(
editor
->
advanced_group
),
GTK_WIDGET
(
editor
->
advanced_rows
->
data
));
editor
->
advanced_rows
=
g_list_delete_link
(
editor
->
advanced_rows
,
editor
->
advanced_rows
);
}
if
(
!
PURPLE_IS_PROTOCOL
(
protocol
))
{
gtk_widget_set_visible
(
editor
->
advanced_group
,
FALSE
);
return
;
}
options
=
purple_protocol_get_account_options
(
protocol
);
if
(
options
==
NULL
)
{
gtk_widget_set_visible
(
editor
->
advanced_group
,
FALSE
);
return
;
}
/* Iterate the options and call our helper which will take ownership of the
* option itself, but we'll delete the list item as we go.
*/
while
(
options
!=
NULL
)
{
pidgin_account_editor_add_advanced_option
(
editor
,
options
->
data
);
options
=
g_list_delete_link
(
options
,
options
);
}
gtk_widget_set_visible
(
editor
->
advanced_group
,
TRUE
);
}
static
void
pidgin_account_editor_update_proxy_options
(
PidginAccountEditor
*
editor
)
{
PurpleProxyInfo
*
info
=
NULL
;
GListModel
*
model
=
NULL
;
const
gchar
*
svalue
=
NULL
;
gint
ivalue
=
0
;
guint
position
=
0
;
if
(
!
PURPLE_IS_ACCOUNT
(
editor
->
account
))
{
return
;
}
info
=
purple_account_get_proxy_info
(
editor
->
account
);
switch
(
purple_proxy_info_get_proxy_type
(
info
))
{
case
PURPLE_PROXY_TYPE_USE_GLOBAL
:
svalue
=
"global"
;
break
;
case
PURPLE_PROXY_TYPE_NONE
:
svalue
=
"none"
;
break
;
case
PURPLE_PROXY_TYPE_SOCKS4
:
svalue
=
"socks4"
;
break
;
case
PURPLE_PROXY_TYPE_SOCKS5
:
svalue
=
"socks5"
;
break
;
case
PURPLE_PROXY_TYPE_TOR
:
svalue
=
"tor"
;
break
;
case
PURPLE_PROXY_TYPE_HTTP
:
svalue
=
"http"
;
break
;
case
PURPLE_PROXY_TYPE_USE_ENVVAR
:
svalue
=
"envvar"
;
break
;
}
model
=
adw_combo_row_get_model
(
ADW_COMBO_ROW
(
editor
->
proxy_type
));
for
(
guint
i
=
0
;
i
<
g_list_model_get_n_items
(
model
);
i
++
)
{
GtkStringObject
*
obj
=
g_list_model_get_item
(
model
,
i
);
if
(
purple_strequal
(
svalue
,
gtk_string_object_get_string
(
obj
)))
{
position
=
i
;
break
;
}
}
adw_combo_row_set_selected
(
ADW_COMBO_ROW
(
editor
->
proxy_type
),
position
);
svalue
=
purple_proxy_info_get_hostname
(
info
);
if
(
svalue
==
NULL
)
{
svalue
=
""
;
}
gtk_editable_set_text
(
GTK_EDITABLE
(
editor
->
proxy_host
),
svalue
);
ivalue
=
purple_proxy_info_get_port
(
info
);
gtk_spin_button_set_value
(
GTK_SPIN_BUTTON
(
editor
->
proxy_port
),
(
gdouble
)
ivalue
);
svalue
=
purple_proxy_info_get_username
(
info
);
if
(
svalue
==
NULL
)
{
svalue
=
""
;
}
gtk_editable_set_text
(
GTK_EDITABLE
(
editor
->
proxy_username
),
svalue
);
svalue
=
purple_proxy_info_get_password
(
info
);
if
(
svalue
==
NULL
)
{
svalue
=
""
;
}
gtk_editable_set_text
(
GTK_EDITABLE
(
editor
->
proxy_password
),
svalue
);
}
static
void
pidgin_account_editor_update
(
PidginAccountEditor
*
editor
)
{
PurpleProtocol
*
protocol
=
NULL
;
gboolean
sensitive
=
FALSE
;
if
(
PURPLE_IS_ACCOUNT
(
editor
->
account
))
{
PurpleConnection
*
connection
=
NULL
;
connection
=
purple_account_get_connection
(
editor
->
account
);
if
(
PURPLE_IS_CONNECTION
(
connection
))
{
gtk_widget_set_sensitive
(
editor
->
protocol
,
FALSE
);
}
}
protocol
=
pidgin_protocol_chooser_get_protocol
(
PIDGIN_PROTOCOL_CHOOSER
(
editor
->
protocol
));
sensitive
=
pidgin_account_editor_update_login_options
(
editor
,
protocol
);
pidgin_account_editor_update_user_options
(
editor
,
protocol
);
pidgin_account_editor_update_advanced_options
(
editor
,
protocol
);
pidgin_account_editor_update_proxy_options
(
editor
);
gtk_dialog_set_response_sensitive
(
GTK_DIALOG
(
editor
),
GTK_RESPONSE_APPLY
,
sensitive
);
}
static
void
pidgin_account_editor_login_options_update_editable
(
PidginAccountEditor
*
editor
)
{
PurpleConnection
*
connection
=
NULL
;
gboolean
editable
=
TRUE
;
if
(
PURPLE_IS_ACCOUNT
(
editor
->
account
))
{
connection
=
purple_account_get_connection
(
editor
->
account
);
/* If we have an active connection, we need to disable everything
* related to the protocol and username.
*/
if
(
PURPLE_IS_CONNECTION
(
connection
))
{
PidginProtocolChooser
*
chooser
=
NULL
;
PurpleProtocol
*
connected_protocol
=
NULL
;
PurpleProtocol
*
selected_protocol
=
NULL
;
editable
=
FALSE
;
/* Check if the user changed the protocol. If they did, switch it
* back and update the editor to reflect what settings are active.
*/
connected_protocol
=
purple_connection_get_protocol
(
connection
);
chooser
=
PIDGIN_PROTOCOL_CHOOSER
(
editor
->
protocol
);
selected_protocol
=
pidgin_protocol_chooser_get_protocol
(
chooser
);
if
(
connected_protocol
!=
selected_protocol
)
{
pidgin_protocol_chooser_set_protocol
(
chooser
,
connected_protocol
);
pidgin_account_editor_update
(
editor
);
}
}
}
gtk_widget_set_sensitive
(
editor
->
protocol
,
editable
);
gtk_editable_set_editable
(
GTK_EDITABLE
(
editor
->
username
),
editable
);
for
(
GList
*
l
=
editor
->
user_split_entries
;
l
!=
NULL
;
l
=
l
->
next
)
{
GtkWidget
*
widget
=
l
->
data
;
gtk_editable_set_editable
(
GTK_EDITABLE
(
widget
),
editable
);
}
}
static
void
pidgin_account_editor_set_account
(
PidginAccountEditor
*
editor
,
PurpleAccount
*
account
)
{
if
(
g_set_object
(
&
editor
->
account
,
account
))
{
if
(
PURPLE_IS_ACCOUNT
(
account
))
{
g_signal_connect
(
account
,
"notify::connection"
,
G_CALLBACK
(
pidgin_account_editor_connection_changed_cb
),
editor
);
}
g_object_notify_by_pspec
(
G_OBJECT
(
editor
),
properties
[
PROP_ACCOUNT
]);
}
pidgin_account_editor_update
(
editor
);
}
static
gboolean
pidgin_account_editor_save_login_options
(
PidginAccountEditor
*
editor
)
{
PurpleProtocol
*
protocol
=
NULL
;
GList
*
split_item
=
NULL
,
*
entry_item
=
NULL
;
GString
*
username
=
NULL
;
const
gchar
*
protocol_id
=
NULL
;
gboolean
new_account
=
FALSE
;
protocol
=
pidgin_protocol_chooser_get_protocol
(
PIDGIN_PROTOCOL_CHOOSER
(
editor
->
protocol
));
protocol_id
=
purple_protocol_get_id
(
protocol
);
username
=
g_string_new
(
gtk_editable_get_text
(
GTK_EDITABLE
(
editor
->
username
)));
split_item
=
purple_protocol_get_user_splits
(
protocol
);
entry_item
=
editor
->
user_split_entries
;
while
(
split_item
!=
NULL
&&
entry_item
!=
NULL
)
{
PurpleAccountUserSplit
*
split
=
split_item
->
data
;
GtkEntry
*
entry
=
entry_item
->
data
;
const
gchar
*
value
=
""
;
gchar
sep
=
'\0'
;
sep
=
purple_account_user_split_get_separator
(
split
);
g_string_append_c
(
username
,
sep
);
if
(
GTK_IS_ENTRY
(
entry
))
{
value
=
gtk_editable_get_text
(
GTK_EDITABLE
(
entry
));
}
if
(
value
==
NULL
||
*
value
==
'\0'
)
{
value
=
purple_account_user_split_get_default_value
(
split
);
}
g_string_append
(
username
,
value
);
split_item
=
split_item
->
next
;
entry_item
=
entry_item
->
next
;
}
if
(
!
PURPLE_IS_ACCOUNT
(
editor
->
account
))
{
editor
->
account
=
purple_account_new
(
username
->
str
,
protocol_id
);
new_account
=
TRUE
;
}
else
{
purple_account_set_username
(
editor
->
account
,
username
->
str
);
purple_account_set_protocol_id
(
editor
->
account
,
protocol_id
);
}
g_string_free
(
username
,
TRUE
);
return
new_account
;
}
static
void
pidgin_account_editor_save_user_options
(
PidginAccountEditor
*
editor
)
{
const
gchar
*
svalue
=
NULL
;
gboolean
bvalue
=
FALSE
;
/* Set the alias. */
svalue
=
gtk_editable_get_text
(
GTK_EDITABLE
(
editor
->
alias
));
if
(
*
svalue
==
'\0'
)
{
svalue
=
NULL
;
}
purple_account_set_private_alias
(
editor
->
account
,
svalue
);
/* Set whether or not to use the global avatar. */
bvalue
=
gtk_switch_get_active
(
GTK_SWITCH
(
editor
->
use_custom_avatar
));
purple_account_set_bool
(
editor
->
account
,
"use-global-buddyicon"
,
!
bvalue
);
if
(
bvalue
)
{
if
(
GDK_IS_PIXBUF
(
editor
->
avatar_pixbuf
))
{
# warning implement this when buddy icons do not suck so bad.
}
else
{
purple_buddy_icons_set_account_icon
(
editor
->
account
,
NULL
,
0
);
}
}
else
{
# warning set the global buddy icon when buddy icons do not suck so bad.
}
}
static
void
pidgin_account_editor_save_advanced_options
(
PidginAccountEditor
*
editor
)
{
for
(
GList
*
l
=
editor
->
advanced_entries
;
l
!=
NULL
;
l
=
l
->
next
)
{
GtkWidget
*
widget
=
l
->
data
;
PurpleAccountOption
*
option
=
NULL
;
GList
*
keys
=
NULL
;
const
gchar
*
setting
=
NULL
;
const
gchar
*
svalue
=
NULL
;
gboolean
bvalue
=
FALSE
;
gint
ivalue
=
0
;
guint
selected
=
0
;
option
=
g_object_get_data
(
G_OBJECT
(
widget
),
"option"
);
setting
=
purple_account_option_get_setting
(
option
);
switch
(
purple_account_option_get_pref_type
(
option
))
{
case
PURPLE_PREF_STRING
:
svalue
=
gtk_editable_get_text
(
GTK_EDITABLE
(
widget
));
purple_account_set_string
(
editor
->
account
,
setting
,
svalue
);
break
;
case
PURPLE_PREF_INT
:
svalue
=
gtk_editable_get_text
(
GTK_EDITABLE
(
widget
));
ivalue
=
atoi
(
svalue
);
purple_account_set_int
(
editor
->
account
,
setting
,
ivalue
);
break
;
case
PURPLE_PREF_BOOLEAN
:
bvalue
=
gtk_switch_get_active
(
GTK_SWITCH
(
widget
));
purple_account_set_bool
(
editor
->
account
,
setting
,
bvalue
);
break
;
case
PURPLE_PREF_STRING_LIST
:
keys
=
g_object_get_data
(
G_OBJECT
(
widget
),
"keys"
);
selected
=
adw_combo_row_get_selected
(
ADW_COMBO_ROW
(
widget
));
svalue
=
g_list_nth_data
(
keys
,
selected
);
purple_account_set_string
(
editor
->
account
,
setting
,
svalue
);
break
;
default
:
break
;
}
}
}
static
void
pidgin_account_editor_save_proxy
(
PidginAccountEditor
*
editor
,
gboolean
new_account
)
{
PurpleProxyInfo
*
info
=
NULL
;
PurpleProxyType
type
=
PURPLE_PROXY_TYPE_NONE
;
GObject
*
item
=
NULL
;
const
gchar
*
svalue
=
NULL
;
gint
ivalue
=
0
;
/* Build the ProxyInfo object */
if
(
new_account
)
{
info
=
purple_proxy_info_new
();
purple_account_set_proxy_info
(
editor
->
account
,
info
);
}
else
{
info
=
purple_account_get_proxy_info
(
editor
->
account
);
}
item
=
adw_combo_row_get_selected_item
(
ADW_COMBO_ROW
(
editor
->
proxy_type
));
svalue
=
gtk_string_object_get_string
(
GTK_STRING_OBJECT
(
item
));
if
(
purple_strequal
(
svalue
,
"global"
))
{
type
=
PURPLE_PROXY_TYPE_USE_GLOBAL
;
}
else
if
(
purple_strequal
(
svalue
,
"none"
))
{
type
=
PURPLE_PROXY_TYPE_NONE
;
}
else
if
(
purple_strequal
(
svalue
,
"socks4"
))
{
type
=
PURPLE_PROXY_TYPE_SOCKS4
;
}
else
if
(
purple_strequal
(
svalue
,
"socks5"
))
{
type
=
PURPLE_PROXY_TYPE_SOCKS5
;
}
else
if
(
purple_strequal
(
svalue
,
"tor"
))
{
type
=
PURPLE_PROXY_TYPE_TOR
;
}
else
if
(
purple_strequal
(
svalue
,
"http"
))
{
type
=
PURPLE_PROXY_TYPE_HTTP
;
}
else
if
(
purple_strequal
(
svalue
,
"envvar"
))
{
type
=
PURPLE_PROXY_TYPE_USE_ENVVAR
;
}
purple_proxy_info_set_proxy_type
(
info
,
type
);
svalue
=
gtk_editable_get_text
(
GTK_EDITABLE
(
editor
->
proxy_host
));
purple_proxy_info_set_hostname
(
info
,
svalue
);
ivalue
=
gtk_spin_button_get_value_as_int
(
GTK_SPIN_BUTTON
(
editor
->
proxy_port
));
purple_proxy_info_set_port
(
info
,
ivalue
);
svalue
=
gtk_editable_get_text
(
GTK_EDITABLE
(
editor
->
proxy_username
));
purple_proxy_info_set_username
(
info
,
svalue
);
svalue
=
gtk_editable_get_text
(
GTK_EDITABLE
(
editor
->
proxy_password
));
purple_proxy_info_set_password
(
info
,
svalue
);
}
static
void
pidgin_account_editor_save_account
(
PidginAccountEditor
*
editor
)
{
gboolean
new_account
=
FALSE
;
new_account
=
pidgin_account_editor_save_login_options
(
editor
);
pidgin_account_editor_save_user_options
(
editor
);
pidgin_account_editor_save_advanced_options
(
editor
);
pidgin_account_editor_save_proxy
(
editor
,
new_account
);
/* If this is a new account, add it to the account manager and bring it
* online.
*/
if
(
new_account
)
{
PurpleAccountManager
*
manager
=
NULL
;
const
PurpleSavedStatus
*
saved_status
;
manager
=
purple_account_manager_get_default
();
purple_account_manager_add
(
manager
,
editor
->
account
);
saved_status
=
purple_savedstatus_get_current
();
if
(
saved_status
!=
NULL
)
{
purple_savedstatus_activate_for_account
(
saved_status
,
editor
->
account
);
purple_account_set_enabled
(
editor
->
account
,
TRUE
);
}
}
}
/******************************************************************************
* Callbacks
*****************************************************************************/
static
void
pidgin_account_editor_connection_changed_cb
(
G_GNUC_UNUSED
GObject
*
obj
,
G_GNUC_UNUSED
GParamSpec
*
pspec
,
gpointer
data
)
{
PidginAccountEditor
*
editor
=
data
;
pidgin_account_editor_login_options_update_editable
(
editor
);
}
static
void
pidgin_account_editor_response_cb
(
GtkDialog
*
dialog
,
gint
response_id
,
G_GNUC_UNUSED
gpointer
data
)
{
if
(
response_id
==
GTK_RESPONSE_APPLY
)
{
pidgin_account_editor_save_account
(
PIDGIN_ACCOUNT_EDITOR
(
dialog
));
}
gtk_window_destroy
(
GTK_WINDOW
(
dialog
));
}
static
void
pidgin_account_editor_protocol_changed_cb
(
G_GNUC_UNUSED
GObject
*
obj
,
G_GNUC_UNUSED
GParamSpec
*
pspec
,
gpointer
data
)
{
pidgin_account_editor_update
(
data
);
}
static
void
pidgin_account_editor_username_changed_cb
(
GtkEditable
*
self
,
gpointer
data
)
{
PidginAccountEditor
*
editor
=
data
;
const
gchar
*
text
=
gtk_editable_get_text
(
self
);
gboolean
sensitive
=
FALSE
;
if
(
text
!=
NULL
&&
*
text
!=
'\0'
)
{
sensitive
=
TRUE
;
}
gtk_dialog_set_response_sensitive
(
GTK_DIALOG
(
editor
),
GTK_RESPONSE_APPLY
,
sensitive
);
}
static
void
pidgin_account_editor_avatar_response_cb
(
GtkNativeDialog
*
self
,
gint
response_id
,
gpointer
data
)
{
PidginAccountEditor
*
editor
=
data
;
if
(
response_id
==
GTK_RESPONSE_ACCEPT
)
{
GError
*
error
=
NULL
;
GFile
*
file
=
NULL
;
gchar
*
filename
=
NULL
;
file
=
gtk_file_chooser_get_file
(
GTK_FILE_CHOOSER
(
self
));
filename
=
g_file_get_path
(
file
);
g_clear_object
(
&
editor
->
avatar_pixbuf
);
editor
->
avatar_pixbuf
=
gdk_pixbuf_new_from_file
(
filename
,
&
error
);
if
(
error
!=
NULL
)
{
g_warning
(
"Failed to create pixbuf from file %s: %s"
,
filename
,
error
->
message
);
g_clear_error
(
&
error
);
}
else
{
gtk_image_set_from_pixbuf
(
GTK_IMAGE
(
editor
->
avatar
),
editor
->
avatar_pixbuf
);
}
g_free
(
filename
);
g_object_unref
(
file
);
}
g_clear_object
(
&
editor
->
avatar_dialog
);
}
static
void
pidgin_account_editor_avatar_set_clicked_cb
(
G_GNUC_UNUSED
GtkButton
*
self
,
gpointer
data
)
{
PidginAccountEditor
*
editor
=
data
;
editor
->
avatar_dialog
=
gtk_file_chooser_native_new
(
_
(
"Buddy Icon"
),
GTK_WINDOW
(
editor
),
GTK_FILE_CHOOSER_ACTION_OPEN
,
_
(
"_Open"
),
_
(
"_Cancel"
));
gtk_native_dialog_set_transient_for
(
GTK_NATIVE_DIALOG
(
editor
->
avatar_dialog
),
GTK_WINDOW
(
editor
));
g_signal_connect
(
G_OBJECT
(
editor
->
avatar_dialog
),
"response"
,
G_CALLBACK
(
pidgin_account_editor_avatar_response_cb
),
editor
);
gtk_native_dialog_show
(
GTK_NATIVE_DIALOG
(
editor
->
avatar_dialog
));
}
static
void
pidgin_account_editor_avatar_remove_clicked_cb
(
G_GNUC_UNUSED
GtkButton
*
self
,
gpointer
data
)
{
PidginAccountEditor
*
editor
=
data
;
gtk_image_set_from_icon_name
(
GTK_IMAGE
(
editor
->
avatar
),
"select-avatar"
);
g_clear_object
(
&
editor
->
avatar_pixbuf
);
}
static
gchar
*
pidgin_account_editor_proxy_type_expression_cb
(
GObject
*
self
,
G_GNUC_UNUSED
gpointer
data
)
{
const
gchar
*
text
=
""
;
const
gchar
*
value
=
NULL
;
value
=
gtk_string_object_get_string
(
GTK_STRING_OBJECT
(
self
));
if
(
purple_strequal
(
value
,
"global"
))
{
text
=
_
(
"Use Global Proxy Settings"
);
}
else
if
(
purple_strequal
(
value
,
"none"
))
{
text
=
_
(
"No proxy"
);
}
else
if
(
purple_strequal
(
value
,
"socks4"
))
{
text
=
_
(
"SOCKS 4"
);
}
else
if
(
purple_strequal
(
value
,
"socks5"
))
{
text
=
_
(
"SOCKS 5"
);
}
else
if
(
purple_strequal
(
value
,
"tor"
))
{
text
=
_
(
"Tor/Privacy (SOCKS 5)"
);
}
else
if
(
purple_strequal
(
value
,
"http"
))
{
text
=
_
(
"HTTP"
);
}
else
if
(
purple_strequal
(
value
,
"envvar"
))
{
text
=
_
(
"Use Environmental Settings"
);
}
return
g_strdup
(
text
);
}
static
void
pidgin_account_editor_proxy_type_changed_cb
(
G_GNUC_UNUSED
GObject
*
obj
,
G_GNUC_UNUSED
GParamSpec
*
pspec
,
gpointer
data
)
{
PidginAccountEditor
*
editor
=
data
;
GObject
*
selected
=
NULL
;
gboolean
show_options
=
TRUE
;
const
gchar
*
value
=
NULL
;
selected
=
adw_combo_row_get_selected_item
(
ADW_COMBO_ROW
(
editor
->
proxy_type
));
value
=
gtk_string_object_get_string
(
GTK_STRING_OBJECT
(
selected
));
if
(
purple_strequal
(
value
,
"global"
)
||
purple_strequal
(
value
,
"none"
)
||
purple_strequal
(
value
,
"envvar"
))
{
show_options
=
FALSE
;
}
gtk_widget_set_visible
(
editor
->
proxy_options
,
show_options
);
}
/******************************************************************************
* GObject Implementation
*****************************************************************************/
G_DEFINE_TYPE
(
PidginAccountEditor
,
pidgin_account_editor
,
GTK_TYPE_DIALOG
)
static
void
pidgin_account_editor_get_property
(
GObject
*
obj
,
guint
param_id
,
GValue
*
value
,
GParamSpec
*
pspec
)
{
PidginAccountEditor
*
editor
=
PIDGIN_ACCOUNT_EDITOR
(
obj
);
switch
(
param_id
)
{
case
PROP_ACCOUNT
:
g_value_set_object
(
value
,
pidgin_account_editor_get_account
(
editor
));
break
;
default
:
G_OBJECT_WARN_INVALID_PROPERTY_ID
(
obj
,
param_id
,
pspec
);
break
;
}
}
static
void
pidgin_account_editor_set_property
(
GObject
*
obj
,
guint
param_id
,
const
GValue
*
value
,
GParamSpec
*
pspec
)
{
PidginAccountEditor
*
editor
=
PIDGIN_ACCOUNT_EDITOR
(
obj
);
switch
(
param_id
)
{
case
PROP_ACCOUNT
:
pidgin_account_editor_set_account
(
editor
,
g_value_get_object
(
value
));
break
;
default
:
G_OBJECT_WARN_INVALID_PROPERTY_ID
(
obj
,
param_id
,
pspec
);
break
;
}
}
static
void
pidgin_account_editor_dispose
(
GObject
*
obj
)
{
PidginAccountEditor
*
editor
=
PIDGIN_ACCOUNT_EDITOR
(
obj
);
g_clear_object
(
&
editor
->
account
);
g_clear_object
(
&
editor
->
avatar_dialog
);
g_clear_object
(
&
editor
->
avatar_pixbuf
);
G_OBJECT_CLASS
(
pidgin_account_editor_parent_class
)
->
dispose
(
obj
);
}
static
void
pidgin_account_editor_init
(
PidginAccountEditor
*
editor
)
{
GtkCssProvider
*
css_provider
=
NULL
;
GtkStyleContext
*
context
=
NULL
;
GtkWidget
*
widget
=
GTK_WIDGET
(
editor
);
gtk_widget_init_template
(
widget
);
css_provider
=
gtk_css_provider_new
();
gtk_css_provider_load_from_resource
(
css_provider
,
"/im/pidgin/Pidgin3/Accounts/entry.css"
);
context
=
gtk_widget_get_style_context
(
GTK_WIDGET
(
editor
));
gtk_style_context_add_provider
(
context
,
GTK_STYLE_PROVIDER
(
css_provider
),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
);
g_clear_object
(
&
css_provider
);
pidgin_account_editor_proxy_type_changed_cb
(
NULL
,
NULL
,
editor
);
}
static
void
pidgin_account_editor_constructed
(
GObject
*
obj
)
{
PidginAccountEditor
*
editor
=
PIDGIN_ACCOUNT_EDITOR
(
obj
);
G_OBJECT_CLASS
(
pidgin_account_editor_parent_class
)
->
constructed
(
obj
);
if
(
PURPLE_IS_ACCOUNT
(
editor
->
account
))
{
pidgin_protocol_chooser_set_protocol
(
PIDGIN_PROTOCOL_CHOOSER
(
editor
->
protocol
),
purple_account_get_protocol
(
editor
->
account
));
}
pidgin_account_editor_update
(
editor
);
pidgin_account_editor_login_options_update_editable
(
editor
);
}
static
void
pidgin_account_editor_finalize
(
GObject
*
obj
)
{
PidginAccountEditor
*
editor
=
PIDGIN_ACCOUNT_EDITOR
(
obj
);
g_clear_pointer
(
&
editor
->
user_split_entries
,
g_list_free
);
g_clear_pointer
(
&
editor
->
user_split_rows
,
g_list_free
);
g_clear_pointer
(
&
editor
->
advanced_entries
,
g_list_free
);
g_clear_pointer
(
&
editor
->
advanced_rows
,
g_list_free
);
G_OBJECT_CLASS
(
pidgin_account_editor_parent_class
)
->
finalize
(
obj
);
}
static
void
pidgin_account_editor_class_init
(
PidginAccountEditorClass
*
klass
)
{
GtkWidgetClass
*
widget_class
=
GTK_WIDGET_CLASS
(
klass
);
GObjectClass
*
obj_class
=
G_OBJECT_CLASS
(
klass
);
obj_class
->
get_property
=
pidgin_account_editor_get_property
;
obj_class
->
set_property
=
pidgin_account_editor_set_property
;
obj_class
->
constructed
=
pidgin_account_editor_constructed
;
obj_class
->
dispose
=
pidgin_account_editor_dispose
;
obj_class
->
finalize
=
pidgin_account_editor_finalize
;
/**
* PidginAccountEditor::account:
*
* The account that this editor is modifying.
*
* Since: 3.0.0
*/
properties
[
PROP_ACCOUNT
]
=
g_param_spec_object
(
"account"
,
"account"
,
"The account to modify"
,
PURPLE_TYPE_ACCOUNT
,
G_PARAM_READWRITE
|
G_PARAM_CONSTRUCT_ONLY
|
G_PARAM_STATIC_STRINGS
);
g_object_class_install_properties
(
obj_class
,
N_PROPERTIES
,
properties
);
gtk_widget_class_set_template_from_resource
(
widget_class
,
"/im/pidgin/Pidgin3/Accounts/editor.ui"
);
/* Dialog */
gtk_widget_class_bind_template_callback
(
widget_class
,
pidgin_account_editor_response_cb
);
/* Login Options */
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
login_options
);
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
protocol
);
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
username
);
gtk_widget_class_bind_template_callback
(
widget_class
,
pidgin_account_editor_protocol_changed_cb
);
gtk_widget_class_bind_template_callback
(
widget_class
,
pidgin_account_editor_username_changed_cb
);
/* User Options */
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
alias
);
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
avatar_row
);
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
use_custom_avatar
);
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
avatar
);
gtk_widget_class_bind_template_callback
(
widget_class
,
pidgin_account_editor_avatar_set_clicked_cb
);
gtk_widget_class_bind_template_callback
(
widget_class
,
pidgin_account_editor_avatar_remove_clicked_cb
);
/* Advanced Options */
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
advanced_group
);
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
advanced_toggle
);
/* Proxy Options */
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
proxy_type
);
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
proxy_options
);
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
proxy_host
);
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
proxy_port
);
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
proxy_username
);
gtk_widget_class_bind_template_child
(
widget_class
,
PidginAccountEditor
,
proxy_password
);
gtk_widget_class_bind_template_callback
(
widget_class
,
pidgin_account_editor_proxy_type_expression_cb
);
gtk_widget_class_bind_template_callback
(
widget_class
,
pidgin_account_editor_proxy_type_changed_cb
);
}
/******************************************************************************
* API
*****************************************************************************/
GtkWidget
*
pidgin_account_editor_new
(
PurpleAccount
*
account
)
{
return
g_object_new
(
PIDGIN_TYPE_ACCOUNT_EDITOR
,
"account"
,
account
,
NULL
);
}
PurpleAccount
*
pidgin_account_editor_get_account
(
PidginAccountEditor
*
editor
)
{
g_return_val_if_fail
(
PIDGIN_IS_ACCOUNT_EDITOR
(
editor
),
NULL
);
return
editor
->
account
;
}