pidgin/pidgin
Clone
Summary
Browse
Changes
Graph
Remove an unused variable
2020-03-13, Gary Kramlich
6ed394abeff1
Remove an unused variable
/*
* finch
*
* Finch 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, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*/
#include
<internal.h>
#include
<gnt.h>
#include
<gntbox.h>
#include
<gntbutton.h>
#include
<gntcheckbox.h>
#include
<gntcombobox.h>
#include
<gntentry.h>
#include
<gntfilesel.h>
#include
<gntlabel.h>
#include
<gntline.h>
#include
<gnttree.h>
#include
"finch.h"
#include
"gntrequest.h"
#include
"debug.h"
#include
"util.h"
typedef
struct
{
void
*
user_data
;
GntWidget
*
dialog
;
GCallback
*
cbs
;
gboolean
save
;
}
FinchFileRequest
;
static
GntWidget
*
setup_request_window
(
const
char
*
title
,
const
char
*
primary
,
const
char
*
secondary
,
PurpleRequestType
type
)
{
GntWidget
*
window
;
window
=
gnt_vbox_new
(
FALSE
);
gnt_box_set_toplevel
(
GNT_BOX
(
window
),
TRUE
);
gnt_box_set_title
(
GNT_BOX
(
window
),
title
);
gnt_box_set_alignment
(
GNT_BOX
(
window
),
GNT_ALIGN_MID
);
if
(
primary
)
gnt_box_add_widget
(
GNT_BOX
(
window
),
gnt_label_new_with_format
(
primary
,
GNT_TEXT_FLAG_BOLD
));
if
(
secondary
)
gnt_box_add_widget
(
GNT_BOX
(
window
),
gnt_label_new
(
secondary
));
g_signal_connect_swapped
(
G_OBJECT
(
window
),
"destroy"
,
G_CALLBACK
(
purple_request_close
),
GINT_TO_POINTER
(
type
));
return
window
;
}
/*
* If the window is closed by the wm (ie, without triggering any of
* the buttons, then do some default callback.
*/
static
void
setup_default_callback
(
GntWidget
*
window
,
gpointer
default_cb
,
gpointer
data
)
{
if
(
default_cb
==
NULL
)
return
;
g_object_set_data
(
G_OBJECT
(
window
),
"default-callback"
,
default_cb
);
g_signal_connect_swapped
(
G_OBJECT
(
window
),
"destroy"
,
G_CALLBACK
(
default_cb
),
data
);
}
static
void
action_performed
(
GntWidget
*
button
,
gpointer
data
)
{
g_signal_handlers_disconnect_matched
(
data
,
G_SIGNAL_MATCH_FUNC
,
0
,
0
,
NULL
,
g_object_get_data
(
data
,
"default-callback"
),
NULL
);
}
/*
* setup_button_box:
* @win: this is the window
* @userdata: the userdata to pass to the primary callbacks
* @cb: the callback
* @data: data for the callback
* @...: (text, primary-callback) pairs, ended by a NULL
*
* The cancellation callback should be the last callback sent.
*/
static
GntWidget
*
setup_button_box
(
GntWidget
*
win
,
gpointer
userdata
,
gpointer
cb
,
gpointer
data
,
...)
{
GntWidget
*
box
;
GntWidget
*
button
=
NULL
;
va_list
list
;
const
char
*
text
;
gpointer
callback
;
box
=
gnt_hbox_new
(
FALSE
);
va_start
(
list
,
data
);
while
((
text
=
va_arg
(
list
,
const
char
*
)))
{
callback
=
va_arg
(
list
,
gpointer
);
button
=
gnt_button_new
(
text
);
gnt_box_add_widget
(
GNT_BOX
(
box
),
button
);
g_object_set_data
(
G_OBJECT
(
button
),
"activate-callback"
,
callback
);
g_object_set_data
(
G_OBJECT
(
button
),
"activate-userdata"
,
userdata
);
g_signal_connect
(
G_OBJECT
(
button
),
"activate"
,
G_CALLBACK
(
action_performed
),
win
);
g_signal_connect
(
G_OBJECT
(
button
),
"activate"
,
G_CALLBACK
(
cb
),
data
);
}
if
(
button
)
g_object_set_data
(
G_OBJECT
(
button
),
"cancellation-function"
,
GINT_TO_POINTER
(
TRUE
));
va_end
(
list
);
return
box
;
}
static
void
notify_input_cb
(
GntWidget
*
button
,
GntWidget
*
entry
)
{
PurpleRequestInputCb
callback
=
g_object_get_data
(
G_OBJECT
(
button
),
"activate-callback"
);
gpointer
data
=
g_object_get_data
(
G_OBJECT
(
button
),
"activate-userdata"
);
const
char
*
text
=
gnt_entry_get_text
(
GNT_ENTRY
(
entry
));
GntWidget
*
window
;
if
(
callback
)
callback
(
data
,
text
);
window
=
gnt_widget_get_toplevel
(
button
);
purple_request_close
(
PURPLE_REQUEST_INPUT
,
window
);
}
static
void
*
finch_request_input
(
const
char
*
title
,
const
char
*
primary
,
const
char
*
secondary
,
const
char
*
default_value
,
gboolean
multiline
,
gboolean
masked
,
gchar
*
hint
,
const
char
*
ok_text
,
GCallback
ok_cb
,
const
char
*
cancel_text
,
GCallback
cancel_cb
,
PurpleRequestCommonParameters
*
cpar
,
void
*
user_data
)
{
GntWidget
*
window
,
*
box
,
*
entry
;
window
=
setup_request_window
(
title
,
primary
,
secondary
,
PURPLE_REQUEST_INPUT
);
entry
=
gnt_entry_new
(
default_value
);
if
(
masked
)
gnt_entry_set_masked
(
GNT_ENTRY
(
entry
),
TRUE
);
gnt_box_add_widget
(
GNT_BOX
(
window
),
entry
);
box
=
setup_button_box
(
window
,
user_data
,
notify_input_cb
,
entry
,
ok_text
,
ok_cb
,
cancel_text
,
cancel_cb
,
NULL
);
gnt_box_add_widget
(
GNT_BOX
(
window
),
box
);
setup_default_callback
(
window
,
cancel_cb
,
user_data
);
gnt_widget_show
(
window
);
return
window
;
}
static
void
finch_close_request
(
PurpleRequestType
type
,
gpointer
ui_handle
)
{
GntWidget
*
widget
=
GNT_WIDGET
(
ui_handle
);
if
(
type
==
PURPLE_REQUEST_FIELDS
)
{
PurpleRequestFields
*
fields
=
g_object_get_data
(
G_OBJECT
(
widget
),
"fields"
);
purple_request_fields_destroy
(
fields
);
}
widget
=
gnt_widget_get_toplevel
(
widget
);
gnt_widget_destroy
(
widget
);
}
static
void
request_choice_cb
(
GntWidget
*
button
,
GntComboBox
*
combo
)
{
PurpleRequestChoiceCb
callback
=
g_object_get_data
(
G_OBJECT
(
button
),
"activate-callback"
);
gpointer
data
=
g_object_get_data
(
G_OBJECT
(
button
),
"activate-userdata"
);
gpointer
choice
=
gnt_combo_box_get_selected_data
(
GNT_COMBO_BOX
(
combo
));
GntWidget
*
window
;
if
(
callback
)
callback
(
data
,
choice
);
window
=
gnt_widget_get_toplevel
(
button
);
purple_request_close
(
PURPLE_REQUEST_INPUT
,
window
);
}
static
void
*
finch_request_choice
(
const
char
*
title
,
const
char
*
primary
,
const
char
*
secondary
,
gpointer
default_value
,
const
char
*
ok_text
,
GCallback
ok_cb
,
const
char
*
cancel_text
,
GCallback
cancel_cb
,
PurpleRequestCommonParameters
*
cpar
,
void
*
user_data
,
va_list
choices
)
{
GntWidget
*
window
,
*
combo
,
*
box
;
const
char
*
text
;
int
val
;
window
=
setup_request_window
(
title
,
primary
,
secondary
,
PURPLE_REQUEST_CHOICE
);
combo
=
gnt_combo_box_new
();
gnt_box_add_widget
(
GNT_BOX
(
window
),
combo
);
while
((
text
=
va_arg
(
choices
,
const
char
*
)))
{
val
=
va_arg
(
choices
,
int
);
gnt_combo_box_add_data
(
GNT_COMBO_BOX
(
combo
),
GINT_TO_POINTER
(
val
+
1
),
text
);
}
gnt_combo_box_set_selected
(
GNT_COMBO_BOX
(
combo
),
default_value
);
box
=
setup_button_box
(
window
,
user_data
,
request_choice_cb
,
combo
,
ok_text
,
ok_cb
,
cancel_text
,
cancel_cb
,
NULL
);
gnt_box_add_widget
(
GNT_BOX
(
window
),
box
);
setup_default_callback
(
window
,
cancel_cb
,
user_data
);
gnt_widget_show
(
window
);
return
window
;
}
static
void
request_action_cb
(
GntWidget
*
button
,
GntWidget
*
window
)
{
PurpleRequestActionCb
callback
=
g_object_get_data
(
G_OBJECT
(
button
),
"activate-callback"
);
gpointer
data
=
g_object_get_data
(
G_OBJECT
(
button
),
"activate-userdata"
);
int
id
=
GPOINTER_TO_INT
(
g_object_get_data
(
G_OBJECT
(
button
),
"activate-id"
));
if
(
callback
)
callback
(
data
,
id
);
purple_request_close
(
PURPLE_REQUEST_ACTION
,
window
);
}
static
void
*
finch_request_action
(
const
char
*
title
,
const
char
*
primary
,
const
char
*
secondary
,
int
default_value
,
PurpleRequestCommonParameters
*
cpar
,
void
*
user_data
,
size_t
actioncount
,
va_list
actions
)
{
GntWidget
*
window
,
*
box
,
*
button
,
*
focus
=
NULL
;
gsize
i
;
window
=
setup_request_window
(
title
,
primary
,
secondary
,
PURPLE_REQUEST_ACTION
);
box
=
gnt_hbox_new
(
FALSE
);
gnt_box_add_widget
(
GNT_BOX
(
window
),
box
);
for
(
i
=
0
;
i
<
actioncount
;
i
++
)
{
const
char
*
text
=
va_arg
(
actions
,
const
char
*
);
PurpleRequestActionCb
callback
=
va_arg
(
actions
,
PurpleRequestActionCb
);
button
=
gnt_button_new
(
text
);
gnt_box_add_widget
(
GNT_BOX
(
box
),
button
);
g_object_set_data
(
G_OBJECT
(
button
),
"activate-callback"
,
callback
);
g_object_set_data
(
G_OBJECT
(
button
),
"activate-userdata"
,
user_data
);
g_object_set_data
(
G_OBJECT
(
button
),
"activate-id"
,
GINT_TO_POINTER
(
i
));
g_signal_connect
(
G_OBJECT
(
button
),
"activate"
,
G_CALLBACK
(
request_action_cb
),
window
);
if
(
default_value
>=
0
&&
i
==
(
gsize
)
default_value
)
focus
=
button
;
}
gnt_widget_show
(
window
);
if
(
focus
)
gnt_box_give_focus_to_child
(
GNT_BOX
(
window
),
focus
);
return
window
;
}
static
void
request_fields_cb
(
GntWidget
*
button
,
PurpleRequestFields
*
fields
)
{
PurpleRequestFieldsCb
callback
=
g_object_get_data
(
G_OBJECT
(
button
),
"activate-callback"
);
gpointer
data
=
g_object_get_data
(
G_OBJECT
(
button
),
"activate-userdata"
);
GList
*
list
;
GntWidget
*
window
;
/* Update the data of the fields. Pidgin does this differently. Instead of
* updating the fields at the end like here, it updates the appropriate field
* instantly whenever a change is made. That allows it to make sure the
* 'required' fields are entered before the user can hit OK. It's not the case
* here, althought it can be done. */
for
(
list
=
purple_request_fields_get_groups
(
fields
);
list
;
list
=
list
->
next
)
{
PurpleRequestFieldGroup
*
group
=
list
->
data
;
GList
*
fields
=
purple_request_field_group_get_fields
(
group
);
for
(;
fields
;
fields
=
fields
->
next
)
{
PurpleRequestField
*
field
=
fields
->
data
;
PurpleRequestFieldType
type
=
purple_request_field_get_field_type
(
field
);
if
(
!
purple_request_field_is_visible
(
field
))
continue
;
if
(
type
==
PURPLE_REQUEST_FIELD_BOOLEAN
)
{
GntWidget
*
check
=
purple_request_field_get_ui_data
(
field
);
gboolean
value
=
gnt_check_box_get_checked
(
GNT_CHECK_BOX
(
check
));
purple_request_field_bool_set_value
(
field
,
value
);
}
else
if
(
type
==
PURPLE_REQUEST_FIELD_STRING
)
{
GntWidget
*
entry
=
purple_request_field_get_ui_data
(
field
);
const
char
*
text
=
gnt_entry_get_text
(
GNT_ENTRY
(
entry
));
purple_request_field_string_set_value
(
field
,
(
text
&&
*
text
)
?
text
:
NULL
);
}
else
if
(
type
==
PURPLE_REQUEST_FIELD_INTEGER
)
{
GntWidget
*
entry
=
purple_request_field_get_ui_data
(
field
);
const
char
*
text
=
gnt_entry_get_text
(
GNT_ENTRY
(
entry
));
int
value
=
(
text
&&
*
text
)
?
atoi
(
text
)
:
0
;
purple_request_field_int_set_value
(
field
,
value
);
}
else
if
(
type
==
PURPLE_REQUEST_FIELD_CHOICE
)
{
GntWidget
*
combo
=
purple_request_field_get_ui_data
(
field
);
gpointer
value
=
gnt_combo_box_get_selected_data
(
GNT_COMBO_BOX
(
combo
));
purple_request_field_choice_set_value
(
field
,
value
);
}
else
if
(
type
==
PURPLE_REQUEST_FIELD_LIST
)
{
GList
*
list
=
NULL
,
*
iter
;
if
(
purple_request_field_list_get_multi_select
(
field
))
{
GntWidget
*
tree
=
purple_request_field_get_ui_data
(
field
);
iter
=
purple_request_field_list_get_items
(
field
);
for
(;
iter
;
iter
=
iter
->
next
)
{
const
char
*
text
=
iter
->
data
;
gpointer
key
=
purple_request_field_list_get_data
(
field
,
text
);
if
(
gnt_tree_get_choice
(
GNT_TREE
(
tree
),
key
))
list
=
g_list_prepend
(
list
,
(
gpointer
)
text
);
}
}
else
{
GntWidget
*
combo
=
purple_request_field_get_ui_data
(
field
);
gpointer
data
=
gnt_combo_box_get_selected_data
(
GNT_COMBO_BOX
(
combo
));
iter
=
purple_request_field_list_get_items
(
field
);
for
(;
iter
;
iter
=
iter
->
next
)
{
const
char
*
text
=
iter
->
data
;
gpointer
key
=
purple_request_field_list_get_data
(
field
,
text
);
if
(
key
==
data
)
{
list
=
g_list_prepend
(
list
,
(
gpointer
)
text
);
break
;
}
}
}
purple_request_field_list_set_selected
(
field
,
list
);
g_list_free
(
list
);
}
else
if
(
type
==
PURPLE_REQUEST_FIELD_ACCOUNT
)
{
GntWidget
*
combo
=
purple_request_field_get_ui_data
(
field
);
PurpleAccount
*
acc
=
gnt_combo_box_get_selected_data
(
GNT_COMBO_BOX
(
combo
));
purple_request_field_account_set_value
(
field
,
acc
);
}
}
}
purple_notify_close_with_handle
(
button
);
if
(
!
g_object_get_data
(
G_OBJECT
(
button
),
"cancellation-function"
)
&&
(
!
purple_request_fields_all_required_filled
(
fields
)
||
!
purple_request_fields_all_valid
(
fields
)))
{
purple_notify_error
(
button
,
_
(
"Error"
),
_
(
"You must properly fill all the required fields."
),
_
(
"The required fields are underlined."
),
NULL
);
return
;
}
if
(
callback
)
callback
(
data
,
fields
);
window
=
gnt_widget_get_toplevel
(
button
);
purple_request_close
(
PURPLE_REQUEST_FIELDS
,
window
);
}
static
void
update_selected_account
(
GntEntry
*
username
,
const
char
*
start
,
const
char
*
end
,
GntComboBox
*
accountlist
)
{
GList
*
accounts
=
gnt_tree_get_rows
(
GNT_TREE
(
gnt_combo_box_get_dropdown
(
accountlist
)));
const
char
*
name
=
gnt_entry_get_text
(
username
);
while
(
accounts
)
{
if
(
purple_blist_find_buddy
(
accounts
->
data
,
name
))
{
gnt_combo_box_set_selected
(
accountlist
,
accounts
->
data
);
gnt_widget_draw
(
GNT_WIDGET
(
accountlist
));
break
;
}
accounts
=
accounts
->
next
;
}
}
static
GntWidget
*
create_boolean_field
(
PurpleRequestField
*
field
)
{
const
char
*
label
=
purple_request_field_get_label
(
field
);
GntWidget
*
check
=
gnt_check_box_new
(
label
);
gnt_check_box_set_checked
(
GNT_CHECK_BOX
(
check
),
purple_request_field_bool_get_default_value
(
field
));
return
check
;
}
static
GntWidget
*
create_string_field
(
PurpleRequestField
*
field
,
GntWidget
**
username
)
{
const
char
*
hint
=
purple_request_field_get_field_type_hint
(
field
);
GntWidget
*
entry
=
gnt_entry_new
(
purple_request_field_string_get_default_value
(
field
));
gnt_entry_set_masked
(
GNT_ENTRY
(
entry
),
purple_request_field_string_is_masked
(
field
));
if
(
hint
&&
g_str_has_prefix
(
hint
,
"screenname"
))
{
PurpleBlistNode
*
node
=
purple_blist_get_default_root
();
gboolean
offline
=
g_str_has_suffix
(
hint
,
"all"
);
for
(;
node
;
node
=
purple_blist_node_next
(
node
,
offline
))
{
if
(
!
PURPLE_IS_BUDDY
(
node
))
continue
;
gnt_entry_add_suggest
(
GNT_ENTRY
(
entry
),
purple_buddy_get_name
((
PurpleBuddy
*
)
node
));
}
gnt_entry_set_always_suggest
(
GNT_ENTRY
(
entry
),
TRUE
);
if
(
username
)
*
username
=
entry
;
}
else
if
(
purple_strequal
(
hint
,
"group"
))
{
PurpleBlistNode
*
node
;
for
(
node
=
purple_blist_get_default_root
();
node
;
node
=
purple_blist_node_get_sibling_next
(
node
))
{
if
(
PURPLE_IS_GROUP
(
node
))
gnt_entry_add_suggest
(
GNT_ENTRY
(
entry
),
purple_group_get_name
((
PurpleGroup
*
)
node
));
}
}
return
entry
;
}
static
GntWidget
*
create_integer_field
(
PurpleRequestField
*
field
)
{
char
str
[
256
];
int
val
=
purple_request_field_int_get_default_value
(
field
);
GntWidget
*
entry
;
g_snprintf
(
str
,
sizeof
(
str
),
"%d"
,
val
);
entry
=
gnt_entry_new
(
str
);
gnt_entry_set_flag
(
GNT_ENTRY
(
entry
),
GNT_ENTRY_FLAG_INT
);
return
entry
;
}
static
GntWidget
*
create_choice_field
(
PurpleRequestField
*
field
)
{
GList
*
it
;
GntWidget
*
combo
=
gnt_combo_box_new
();
it
=
purple_request_field_choice_get_elements
(
field
);
while
(
it
!=
NULL
)
{
const
gchar
*
text
;
gpointer
value
;
text
=
it
->
data
;
it
=
g_list_next
(
it
);
g_assert
(
it
!=
NULL
);
value
=
it
->
data
;
it
=
g_list_next
(
it
);
gnt_combo_box_add_data
(
GNT_COMBO_BOX
(
combo
),
value
,
text
);
}
gnt_combo_box_set_selected
(
GNT_COMBO_BOX
(
combo
),
purple_request_field_choice_get_default_value
(
field
));
return
combo
;
}
static
GntWidget
*
create_list_field
(
PurpleRequestField
*
field
)
{
GntWidget
*
ret
=
NULL
;
GList
*
list
;
gboolean
multi
=
purple_request_field_list_get_multi_select
(
field
);
if
(
multi
)
{
GntWidget
*
tree
=
gnt_tree_new
();
list
=
purple_request_field_list_get_items
(
field
);
for
(;
list
;
list
=
list
->
next
)
{
const
char
*
text
=
list
->
data
;
gpointer
key
=
purple_request_field_list_get_data
(
field
,
text
);
gnt_tree_add_choice
(
GNT_TREE
(
tree
),
key
,
gnt_tree_create_row
(
GNT_TREE
(
tree
),
text
),
NULL
,
NULL
);
if
(
purple_request_field_list_is_selected
(
field
,
text
))
gnt_tree_set_choice
(
GNT_TREE
(
tree
),
key
,
TRUE
);
}
ret
=
tree
;
}
else
{
GntWidget
*
combo
=
gnt_combo_box_new
();
list
=
purple_request_field_list_get_items
(
field
);
for
(;
list
;
list
=
list
->
next
)
{
const
char
*
text
=
list
->
data
;
gpointer
key
=
purple_request_field_list_get_data
(
field
,
text
);
gnt_combo_box_add_data
(
GNT_COMBO_BOX
(
combo
),
key
,
text
);
if
(
purple_request_field_list_is_selected
(
field
,
text
))
gnt_combo_box_set_selected
(
GNT_COMBO_BOX
(
combo
),
key
);
}
ret
=
combo
;
}
return
ret
;
}
static
GntWidget
*
create_account_field
(
PurpleRequestField
*
field
)
{
gboolean
all
;
PurpleAccount
*
def
;
GList
*
list
;
GntWidget
*
combo
=
gnt_combo_box_new
();
all
=
purple_request_field_account_get_show_all
(
field
);
def
=
purple_request_field_account_get_value
(
field
);
if
(
!
def
)
def
=
purple_request_field_account_get_default_value
(
field
);
if
(
all
)
list
=
purple_accounts_get_all
();
else
list
=
purple_connections_get_all
();
for
(;
list
;
list
=
list
->
next
)
{
PurpleAccount
*
account
;
char
*
text
;
if
(
all
)
account
=
list
->
data
;
else
account
=
purple_connection_get_account
(
list
->
data
);
text
=
g_strdup_printf
(
"%s (%s)"
,
purple_account_get_username
(
account
),
purple_account_get_protocol_name
(
account
));
gnt_combo_box_add_data
(
GNT_COMBO_BOX
(
combo
),
account
,
text
);
g_free
(
text
);
if
(
account
==
def
)
gnt_combo_box_set_selected
(
GNT_COMBO_BOX
(
combo
),
account
);
}
gnt_widget_set_size
(
combo
,
20
,
3
);
/* ew */
return
combo
;
}
static
void
multifield_extra_cb
(
GntWidget
*
button
,
PurpleRequestFields
*
allfields
)
{
PurpleRequestFieldsCb
cb
;
gpointer
cb_data
;
gpointer
handle
;
handle
=
g_object_get_data
(
G_OBJECT
(
button
),
"ui-handle"
);
cb
=
g_object_get_data
(
G_OBJECT
(
button
),
"extra-cb"
);
cb_data
=
g_object_get_data
(
G_OBJECT
(
button
),
"extra-cb-data"
);
if
(
cb
!=
NULL
)
cb
(
cb_data
,
allfields
);
action_performed
(
button
,
handle
);
purple_request_close
(
PURPLE_REQUEST_FIELDS
,
handle
);
}
static
void
*
finch_request_fields
(
const
char
*
title
,
const
char
*
primary
,
const
char
*
secondary
,
PurpleRequestFields
*
allfields
,
const
char
*
ok
,
GCallback
ok_cb
,
const
char
*
cancel
,
GCallback
cancel_cb
,
PurpleRequestCommonParameters
*
cpar
,
void
*
userdata
)
{
GntWidget
*
window
,
*
box
;
GList
*
grlist
;
GntWidget
*
username
=
NULL
,
*
accountlist
=
NULL
;
PurpleRequestHelpCb
help_cb
;
gpointer
help_data
;
GSList
*
extra_actions
,
*
it
;
window
=
setup_request_window
(
title
,
primary
,
secondary
,
PURPLE_REQUEST_FIELDS
);
/* This is how it's going to work: the request-groups are going to be
* stacked vertically one after the other. A GntLine will be separating
* the groups. */
box
=
gnt_vbox_new
(
FALSE
);
gnt_box_set_pad
(
GNT_BOX
(
box
),
0
);
gnt_box_set_fill
(
GNT_BOX
(
box
),
TRUE
);
for
(
grlist
=
purple_request_fields_get_groups
(
allfields
);
grlist
;
grlist
=
grlist
->
next
)
{
PurpleRequestFieldGroup
*
group
=
grlist
->
data
;
GList
*
fields
=
purple_request_field_group_get_fields
(
group
);
GntWidget
*
hbox
;
const
char
*
title
=
purple_request_field_group_get_title
(
group
);
if
(
title
)
gnt_box_add_widget
(
GNT_BOX
(
box
),
gnt_label_new_with_format
(
title
,
GNT_TEXT_FLAG_BOLD
));
for
(;
fields
;
fields
=
fields
->
next
)
{
PurpleRequestField
*
field
=
fields
->
data
;
PurpleRequestFieldType
type
=
purple_request_field_get_field_type
(
field
);
const
char
*
label
=
purple_request_field_get_label
(
field
);
if
(
!
purple_request_field_is_visible
(
field
))
continue
;
hbox
=
gnt_hbox_new
(
TRUE
);
/* hrm */
gnt_box_add_widget
(
GNT_BOX
(
box
),
hbox
);
if
(
type
!=
PURPLE_REQUEST_FIELD_BOOLEAN
&&
label
)
{
GntWidget
*
l
;
if
(
purple_request_field_is_required
(
field
))
l
=
gnt_label_new_with_format
(
label
,
GNT_TEXT_FLAG_UNDERLINE
);
else
l
=
gnt_label_new
(
label
);
gnt_widget_set_size
(
l
,
0
,
1
);
gnt_box_add_widget
(
GNT_BOX
(
hbox
),
l
);
}
if
(
type
==
PURPLE_REQUEST_FIELD_BOOLEAN
)
{
purple_request_field_set_ui_data
(
field
,
create_boolean_field
(
field
));
}
else
if
(
type
==
PURPLE_REQUEST_FIELD_STRING
)
{
purple_request_field_set_ui_data
(
field
,
create_string_field
(
field
,
&
username
));
}
else
if
(
type
==
PURPLE_REQUEST_FIELD_INTEGER
)
{
purple_request_field_set_ui_data
(
field
,
create_integer_field
(
field
));
}
else
if
(
type
==
PURPLE_REQUEST_FIELD_CHOICE
)
{
purple_request_field_set_ui_data
(
field
,
create_choice_field
(
field
));
}
else
if
(
type
==
PURPLE_REQUEST_FIELD_LIST
)
{
purple_request_field_set_ui_data
(
field
,
create_list_field
(
field
));
}
else
if
(
type
==
PURPLE_REQUEST_FIELD_ACCOUNT
)
{
accountlist
=
create_account_field
(
field
);
purple_request_field_set_ui_data
(
field
,
accountlist
);
}
else
{
purple_request_field_set_ui_data
(
field
,
gnt_label_new_with_format
(
_
(
"Not implemented yet."
),
GNT_TEXT_FLAG_BOLD
));
}
gnt_box_set_alignment
(
GNT_BOX
(
hbox
),
GNT_ALIGN_MID
);
gnt_box_add_widget
(
GNT_BOX
(
hbox
),
GNT_WIDGET
(
purple_request_field_get_ui_data
(
field
)));
}
if
(
grlist
->
next
)
gnt_box_add_widget
(
GNT_BOX
(
box
),
gnt_hline_new
());
}
gnt_box_add_widget
(
GNT_BOX
(
window
),
box
);
box
=
setup_button_box
(
window
,
userdata
,
request_fields_cb
,
allfields
,
ok
,
ok_cb
,
cancel
,
cancel_cb
,
NULL
);
extra_actions
=
purple_request_cpar_get_extra_actions
(
cpar
);
for
(
it
=
extra_actions
;
it
;
it
=
it
->
next
->
next
)
{
const
gchar
*
label
=
it
->
data
;
PurpleRequestFieldsCb
*
cb
=
it
->
next
->
data
;
GntWidget
*
button
=
gnt_button_new
(
label
);
gnt_box_add_widget_in_front
(
GNT_BOX
(
box
),
button
);
g_object_set_data
(
G_OBJECT
(
button
),
"ui-handle"
,
window
);
g_object_set_data
(
G_OBJECT
(
button
),
"extra-cb"
,
cb
);
g_object_set_data
(
G_OBJECT
(
button
),
"extra-cb-data"
,
userdata
);
g_signal_connect
(
G_OBJECT
(
button
),
"activate"
,
G_CALLBACK
(
multifield_extra_cb
),
allfields
);
}
help_cb
=
purple_request_cpar_get_help_cb
(
cpar
,
&
help_data
);
if
(
help_cb
)
{
GntWidget
*
button
=
gnt_button_new
(
_
(
"Help"
));
gnt_box_add_widget_in_front
(
GNT_BOX
(
box
),
button
);
g_signal_connect_swapped
(
G_OBJECT
(
button
),
"activate"
,
G_CALLBACK
(
help_cb
),
help_data
);
}
gnt_box_add_widget
(
GNT_BOX
(
window
),
box
);
setup_default_callback
(
window
,
cancel_cb
,
userdata
);
gnt_widget_show
(
window
);
if
(
username
&&
accountlist
)
{
g_signal_connect
(
username
,
"completion"
,
G_CALLBACK
(
update_selected_account
),
accountlist
);
}
g_object_set_data
(
G_OBJECT
(
window
),
"fields"
,
allfields
);
return
window
;
}
static
void
file_cancel_cb
(
GntWidget
*
wid
,
gpointer
fq
)
{
FinchFileRequest
*
data
=
fq
;
if
(
data
->
dialog
==
NULL
)
{
/* We've already handled this request, and are in the destroy handler. */
return
;
}
if
(
data
->
cbs
[
1
]
!=
NULL
)
((
PurpleRequestFileCb
)
data
->
cbs
[
1
])(
data
->
user_data
,
NULL
);
purple_request_close
(
PURPLE_REQUEST_FILE
,
data
->
dialog
);
data
->
dialog
=
NULL
;
}
static
void
file_ok_cb
(
GntWidget
*
widget
,
const
char
*
path
,
const
char
*
file
,
gpointer
fq
)
{
FinchFileRequest
*
data
=
fq
;
char
*
dir
=
g_path_get_dirname
(
path
);
if
(
data
->
cbs
[
0
]
!=
NULL
)
((
PurpleRequestFileCb
)
data
->
cbs
[
0
])(
data
->
user_data
,
file
);
purple_prefs_set_path
(
data
->
save
?
"/finch/filelocations/last_save_folder"
:
"/finch/filelocations/last_open_folder"
,
dir
);
g_free
(
dir
);
purple_request_close
(
PURPLE_REQUEST_FILE
,
data
->
dialog
);
data
->
dialog
=
NULL
;
}
static
void
file_request_destroy
(
FinchFileRequest
*
data
)
{
g_free
(
data
->
cbs
);
g_free
(
data
);
}
static
FinchFileRequest
*
finch_file_request_window
(
const
char
*
title
,
const
char
*
path
,
GCallback
ok_cb
,
GCallback
cancel_cb
,
void
*
user_data
)
{
GntWidget
*
window
=
gnt_file_sel_new
();
GntFileSel
*
sel
=
GNT_FILE_SEL
(
window
);
FinchFileRequest
*
data
=
g_new0
(
FinchFileRequest
,
1
);
data
->
user_data
=
user_data
;
data
->
cbs
=
g_new0
(
GCallback
,
2
);
data
->
cbs
[
0
]
=
ok_cb
;
data
->
cbs
[
1
]
=
cancel_cb
;
data
->
dialog
=
window
;
gnt_box_set_title
(
GNT_BOX
(
window
),
title
);
gnt_file_sel_set_current_location
(
sel
,
(
path
&&
*
path
)
?
path
:
purple_home_dir
());
g_signal_connect
(
G_OBJECT
(
sel
),
"destroy"
,
G_CALLBACK
(
file_cancel_cb
),
data
);
g_signal_connect
(
G_OBJECT
(
sel
),
"cancelled"
,
G_CALLBACK
(
file_cancel_cb
),
data
);
g_signal_connect
(
G_OBJECT
(
sel
),
"file_selected"
,
G_CALLBACK
(
file_ok_cb
),
data
);
g_object_set_data_full
(
G_OBJECT
(
window
),
"filerequestdata"
,
data
,
(
GDestroyNotify
)
file_request_destroy
);
return
data
;
}
static
void
*
finch_request_file
(
const
char
*
title
,
const
char
*
filename
,
gboolean
savedialog
,
GCallback
ok_cb
,
GCallback
cancel_cb
,
PurpleRequestCommonParameters
*
cpar
,
void
*
user_data
)
{
FinchFileRequest
*
data
;
const
char
*
path
;
path
=
purple_prefs_get_path
(
savedialog
?
"/finch/filelocations/last_save_folder"
:
"/finch/filelocations/last_open_folder"
);
data
=
finch_file_request_window
(
title
?
title
:
(
savedialog
?
_
(
"Save File..."
)
:
_
(
"Open File..."
)),
path
,
ok_cb
,
cancel_cb
,
user_data
);
data
->
save
=
savedialog
;
if
(
savedialog
)
gnt_file_sel_set_suggested_filename
(
GNT_FILE_SEL
(
data
->
dialog
),
filename
);
gnt_widget_show
(
data
->
dialog
);
return
data
->
dialog
;
}
static
void
*
finch_request_folder
(
const
char
*
title
,
const
char
*
dirname
,
GCallback
ok_cb
,
GCallback
cancel_cb
,
PurpleRequestCommonParameters
*
cpar
,
void
*
user_data
)
{
FinchFileRequest
*
data
;
data
=
finch_file_request_window
(
title
?
title
:
_
(
"Choose Location..."
),
dirname
,
ok_cb
,
cancel_cb
,
user_data
);
data
->
save
=
TRUE
;
gnt_file_sel_set_dirs_only
(
GNT_FILE_SEL
(
data
->
dialog
),
TRUE
);
gnt_widget_show
(
data
->
dialog
);
return
data
->
dialog
;
}
static
PurpleRequestUiOps
uiops
=
{
0
,
finch_request_input
,
finch_request_choice
,
finch_request_action
,
NULL
,
NULL
,
finch_request_fields
,
finch_request_file
,
finch_request_folder
,
finch_close_request
,
NULL
,
NULL
,
NULL
,
NULL
};
PurpleRequestUiOps
*
finch_request_get_ui_ops
()
{
return
&
uiops
;
}
void
finch_request_init
()
{
}
void
finch_request_uninit
()
{
}
void
finch_request_save_in_prefs
(
gpointer
data
,
PurpleRequestFields
*
allfields
)
{
GList
*
list
;
for
(
list
=
purple_request_fields_get_groups
(
allfields
);
list
;
list
=
list
->
next
)
{
PurpleRequestFieldGroup
*
group
=
list
->
data
;
GList
*
fields
=
purple_request_field_group_get_fields
(
group
);
for
(;
fields
;
fields
=
fields
->
next
)
{
PurpleRequestField
*
field
=
fields
->
data
;
PurpleRequestFieldType
type
=
purple_request_field_get_field_type
(
field
);
PurplePrefType
pt
;
gpointer
val
=
NULL
;
const
char
*
id
=
purple_request_field_get_id
(
field
);
switch
(
type
)
{
case
PURPLE_REQUEST_FIELD_LIST
:
val
=
purple_request_field_list_get_selected
(
field
)
->
data
;
val
=
purple_request_field_list_get_data
(
field
,
val
);
break
;
case
PURPLE_REQUEST_FIELD_BOOLEAN
:
val
=
GINT_TO_POINTER
(
purple_request_field_bool_get_value
(
field
));
break
;
case
PURPLE_REQUEST_FIELD_INTEGER
:
val
=
GINT_TO_POINTER
(
purple_request_field_int_get_value
(
field
));
break
;
case
PURPLE_REQUEST_FIELD_STRING
:
val
=
(
gpointer
)
purple_request_field_string_get_value
(
field
);
break
;
default
:
break
;
}
pt
=
purple_prefs_get_pref_type
(
id
);
switch
(
pt
)
{
case
PURPLE_PREF_INT
:
{
long
int
tmp
=
GPOINTER_TO_INT
(
val
);
if
(
type
==
PURPLE_REQUEST_FIELD_LIST
)
{
/* Lists always return string */
if
(
sscanf
(
val
,
"%ld"
,
&
tmp
)
!=
1
)
tmp
=
0
;
}
purple_prefs_set_int
(
id
,
(
gint
)
tmp
);
break
;
}
case
PURPLE_PREF_BOOLEAN
:
purple_prefs_set_bool
(
id
,
GPOINTER_TO_INT
(
val
));
break
;
case
PURPLE_PREF_STRING
:
purple_prefs_set_string
(
id
,
val
);
break
;
default
:
break
;
}
}
}
}
GntWidget
*
finch_request_field_get_widget
(
PurpleRequestField
*
field
)
{
GntWidget
*
ret
=
NULL
;
switch
(
purple_request_field_get_field_type
(
field
))
{
case
PURPLE_REQUEST_FIELD_BOOLEAN
:
ret
=
create_boolean_field
(
field
);
break
;
case
PURPLE_REQUEST_FIELD_STRING
:
ret
=
create_string_field
(
field
,
NULL
);
break
;
case
PURPLE_REQUEST_FIELD_INTEGER
:
ret
=
create_integer_field
(
field
);
break
;
case
PURPLE_REQUEST_FIELD_CHOICE
:
ret
=
create_choice_field
(
field
);
break
;
case
PURPLE_REQUEST_FIELD_LIST
:
ret
=
create_list_field
(
field
);
break
;
case
PURPLE_REQUEST_FIELD_ACCOUNT
:
ret
=
create_account_field
(
field
);
break
;
default
:
purple_debug_error
(
"GntRequest"
,
"Unimplemented request-field %d
\n
"
,
purple_request_field_get_field_type
(
field
));
break
;
}
return
ret
;
}