void tag_apply_open(GSList *msglist)
{
if (!applywindow.window)
apply_window_create();
manage_window_set_transient(GTK_WINDOW(applywindow.window));
gtk_widget_grab_focus(applywindow.close_btn);
applywindow.msglist = msglist;
apply_window_load_tags();
if (msglist && !applywindow.has_tag_col) {
apply_window_insert_check_column(applywindow.taglist);
applywindow.has_tag_col = TRUE;
}
if (!msglist && applywindow.has_tag_col) {
gtk_tree_view_remove_column(GTK_TREE_VIEW(applywindow.taglist),
gtk_tree_view_get_column(GTK_TREE_VIEW(applywindow.taglist), 0));
applywindow.has_tag_col = FALSE;
}
gtk_widget_show(applywindow.window);
gtk_widget_grab_focus(applywindow.taglist);
gtk_window_set_modal(GTK_WINDOW(applywindow.window), TRUE);
}
/**
* Process export address dialog.
* \param cache Address book/data source cache.
*/
void addressbook_exp_html( AddressCache *cache ) {
/* Set references to control data */
_addressCache_ = cache;
_exportCtl_ = exporthtml_create();
exporthtml_load_settings( _exportCtl_ );
/* Setup GUI */
if( ! exphtml_dlg.window )
export_html_create();
exphtml_dlg.cancelled = FALSE;
gtk_widget_show(exphtml_dlg.window);
manage_window_set_transient(GTK_WINDOW(exphtml_dlg.window));
gtk_label_set_text( GTK_LABEL(exphtml_dlg.labelBook), cache->name );
gtk_label_set_text( GTK_LABEL(exphtml_dlg.labelOutBook), cache->name );
export_html_fill_fields( _exportCtl_ );
gtk_widget_grab_default(exphtml_dlg.btnNext);
gtk_notebook_set_page( GTK_NOTEBOOK(exphtml_dlg.notebook), PAGE_FILE_INFO );
gtk_widget_set_sensitive( exphtml_dlg.btnPrev, FALSE );
gtk_widget_set_sensitive( exphtml_dlg.btnNext, TRUE );
export_html_message();
gtk_widget_grab_focus(exphtml_dlg.entryHtml);
gtk_main();
gtk_widget_hide(exphtml_dlg.window);
exporthtml_free( _exportCtl_ );
_exportCtl_ = NULL;
_addressCache_ = NULL;
}
void uri_opener_open(MessageView *msgview, GSList *uris)
{
cm_return_if_fail(msgview);
cm_return_if_fail(msgview->mimeview);
cm_return_if_fail(msgview->mimeview->textview);
cm_return_if_fail(msgview);
if (!opener.window)
uri_opener_create();
manage_window_set_transient(GTK_WINDOW(opener.window));
gtk_widget_grab_focus(opener.close_btn);
if (uris == NULL) {
alertpanel_notice(_("There are no URLs in this email."));
return;
}
opener.msgview = msgview;
opener.uris = g_slist_copy(uris);
uri_opener_load_uris();
gtk_widget_show(opener.window);
gtk_widget_grab_focus(opener.urilist);
gtk_window_set_modal(GTK_WINDOW(opener.window), TRUE);
}
AddressBookFile *addressbook_imp_pine( AddressIndex *addrIndex ) {
static gboolean cancelled;
gchar *pineFile;
_importedBook_ = NULL;
_imp_addressIndex_ = addrIndex;
if( ! imppine_dlg.window )
imp_pine_create(&cancelled);
gtk_widget_grab_focus(imppine_dlg.ok_btn);
gtk_widget_grab_focus(imppine_dlg.file_entry);
gtk_widget_show(imppine_dlg.window);
manage_window_set_transient(GTK_WINDOW(imppine_dlg.window));
gtk_window_set_modal(GTK_WINDOW(imppine_dlg.window), TRUE);
imp_pine_status_show( _( "Please select a file to import." ) );
pineFile = pine_find_file();
gtk_entry_set_text( GTK_ENTRY(imppine_dlg.name_entry), IMPORTPINE_GUESS_NAME );
gtk_entry_set_text( GTK_ENTRY(imppine_dlg.file_entry), pineFile );
g_free( pineFile );
pineFile = NULL;
gtk_main();
gtk_widget_hide(imppine_dlg.window);
gtk_window_set_modal(GTK_WINDOW(imppine_dlg.window), FALSE);
_imp_addressIndex_ = NULL;
if (cancelled == TRUE) return NULL;
return _importedBook_;
}
/*!
*\brief Opens the filtering action dialog with a list of actions
*
*\param matchers List of conditions
*\param cb Callback
*
*/
void prefs_filtering_action_open(GSList *action_list,
PrefsFilteringActionSignal *cb)
{
inc_lock();
if (!filtering_action.window) {
prefs_filtering_action_create();
} else {
#if !GTK_CHECK_VERSION(3, 0, 0)
/* update color label menu */
gtk_cmoption_menu_set_menu(GTK_CMOPTION_MENU(filtering_action.color_optmenu),
colorlabel_create_color_menu());
#endif
}
manage_window_set_transient(GTK_WINDOW(filtering_action.window));
gtk_widget_grab_focus(filtering_action.ok_btn);
filtering_action_callback = cb;
prefs_filtering_action_set_dialog(action_list);
gtk_widget_show(filtering_action.window);
gtk_window_set_modal(GTK_WINDOW(filtering_action.window), TRUE);
}
gchar *edit_ldap_basedn_selection( const gchar *hostName, const gint port, gchar *baseDN, const gint tov,
const gchar* bindDN, const gchar *bindPW, int ssl, int tls ) {
gchar *retVal = NULL;
ldapedit_basedn_cancelled = FALSE;
if( ! ldapedit_basedn.window ) edit_ldap_bdn_create();
gtk_widget_grab_focus(ldapedit_basedn.ok_btn);
gtk_widget_show(ldapedit_basedn.window);
manage_window_set_transient(GTK_WINDOW(ldapedit_basedn.window));
gtk_window_set_modal(GTK_WINDOW(ldapedit_basedn.window), TRUE);
edit_ldap_bdn_status_show( "" );
edit_ldap_bdn_load_data( hostName, port, tov, bindDN, bindPW, ssl, tls );
gtk_widget_show(ldapedit_basedn.window);
gtk_entry_set_text(GTK_ENTRY(ldapedit_basedn.basedn_entry), baseDN);
gtk_main();
gtk_widget_hide(ldapedit_basedn.window);
gtk_window_set_modal(GTK_WINDOW(ldapedit_basedn.window), FALSE);
if( ldapedit_basedn_cancelled ) return NULL;
if( ldapedit_basedn_bad_server ) return NULL;
retVal = gtk_editable_get_chars( GTK_EDITABLE(ldapedit_basedn.basedn_entry), 0, -1 );
g_strchomp( retVal ); g_strchug( retVal );
if( *retVal == '\0' ) {
g_free( retVal );
retVal = NULL;
}
return retVal;
}
AdapterDSource *addressbook_edit_vcard( AddressIndex *addrIndex, AdapterDSource *ads ) {
static gboolean cancelled;
gchar *sName;
gchar *sFile;
AddressDataSource *ds = NULL;
VCardFile *vcf = NULL;
gboolean fin;
if( ! vcardedit.window )
addressbook_edit_vcard_create(&cancelled);
gtk_widget_grab_focus(vcardedit.ok_btn);
gtk_widget_grab_focus(vcardedit.name_entry);
gtk_widget_show(vcardedit.window);
manage_window_set_transient(GTK_WINDOW(vcardedit.window));
edit_vcard_status_show( "" );
if( ads ) {
ds = ads->dataSource;
vcf = ds->rawDataSource;
if ( vcard_get_name( vcf ) )
gtk_entry_set_text(GTK_ENTRY(vcardedit.name_entry), vcard_get_name( vcf ) );
if (vcf->path)
gtk_entry_set_text(GTK_ENTRY(vcardedit.file_entry), vcf->path);
gtk_window_set_title( GTK_WINDOW(vcardedit.window), _("Edit vCard Entry"));
}
else {
gtk_entry_set_text(GTK_ENTRY(vcardedit.name_entry), ADDRESSBOOK_GUESS_VCARD );
gtk_entry_set_text(GTK_ENTRY(vcardedit.file_entry), vcard_find_gnomecard() );
gtk_window_set_title( GTK_WINDOW(vcardedit.window), _("Add New vCard Entry"));
}
gtk_main();
gtk_widget_hide(vcardedit.window);
if (cancelled == TRUE) return NULL;
fin = FALSE;
sName = gtk_editable_get_chars( GTK_EDITABLE(vcardedit.name_entry), 0, -1 );
sFile = gtk_editable_get_chars( GTK_EDITABLE(vcardedit.file_entry), 0, -1 );
if( *sName == '\0' ) fin = TRUE;
if( *sFile == '\0' ) fin = TRUE;
if( ! fin ) {
if( ! ads ) {
vcf = vcard_create();
ds = addrindex_index_add_datasource( addrIndex, ADDR_IF_VCARD, vcf );
ads = addressbook_create_ds_adapter( ds, ADDR_VCARD, NULL );
}
addressbook_ads_set_name( ads, sName );
vcard_set_name( vcf, sName );
vcard_set_file( vcf, sFile );
}
g_free( sName );
g_free( sFile );
return ads;
}
void description_window_create(DescriptionWindow *dwindow)
{
if (!dwindow->window)
description_create(dwindow);
manage_window_set_transient(GTK_WINDOW(dwindow->window));
gtk_widget_show(dwindow->window);
gtk_main();
gtk_widget_hide(dwindow->window);
}
static void
open_dialog (struct select_keys_s *sk)
{
if (!sk->window)
create_dialog (sk);
manage_window_set_transient (GTK_WINDOW (sk->window));
sk->okay = 0;
sk->sort_column = N_COL_TITLES; /* use an invalid value */
sk->sort_type = GTK_SORT_ASCENDING;
}
/**
* Import LDIF file.
* \param addrIndex Address index.
* \return Address book file of imported data, or <i>NULL</i> if import
* was cancelled.
*/
AddressBookFile *addressbook_imp_ldif( AddressIndex *addrIndex ) {
_importedBook_ = NULL;
_imp_addressIndex_ = addrIndex;
if( ! impldif_dlg.window )
imp_ldif_create();
gtk_button_set_label(GTK_BUTTON(impldif_dlg.btnCancel),
GTK_STOCK_CANCEL);
gtk_widget_hide(impldif_dlg.btnProceed);
gtk_widget_show(impldif_dlg.btnNext);
impldif_dlg.cancelled = FALSE;
gtk_widget_show(impldif_dlg.window);
manage_window_set_transient(GTK_WINDOW(impldif_dlg.window));
gtk_widget_grab_default(impldif_dlg.btnNext);
gtk_window_set_modal(GTK_WINDOW(impldif_dlg.window), TRUE);
gtk_entry_set_text( GTK_ENTRY(impldif_dlg.entryName), IMPORTLDIF_GUESS_NAME );
gtk_entry_set_text( GTK_ENTRY(impldif_dlg.entryFile), "" );
gtk_label_set_text( GTK_LABEL(impldif_dlg.entryField), "" );
gtk_entry_set_text( GTK_ENTRY(impldif_dlg.entryAttrib), "" );
gtk_cmclist_clear( GTK_CMCLIST(impldif_dlg.clist_field) );
gtk_notebook_set_current_page( GTK_NOTEBOOK(impldif_dlg.notebook), PAGE_FILE_INFO );
gtk_widget_set_sensitive( impldif_dlg.btnPrev, FALSE );
gtk_widget_set_sensitive( impldif_dlg.btnNext, TRUE );
stock_pixbuf_gdk(STOCK_PIXMAP_MARK, &markxpm );
imp_ldif_message();
gtk_widget_grab_focus(impldif_dlg.entryFile);
impldif_dlg.rowIndSelect = -1;
impldif_dlg.rowCount = 0;
g_free( impldif_dlg.nameBook );
g_free( impldif_dlg.fileName );
impldif_dlg.nameBook = NULL;
impldif_dlg.fileName = NULL;
_ldifFile_ = ldif_create();
gtk_main();
gtk_widget_hide(impldif_dlg.window);
gtk_window_set_modal(GTK_WINDOW(impldif_dlg.window), FALSE);
ldif_free( _ldifFile_ );
_ldifFile_ = NULL;
_imp_addressIndex_ = NULL;
g_free( impldif_dlg.nameBook );
g_free( impldif_dlg.fileName );
impldif_dlg.nameBook = NULL;
impldif_dlg.fileName = NULL;
if( impldif_dlg.cancelled == TRUE ) return NULL;
return _importedBook_;
}
void ssl_manager_open(MainWindow *mainwin)
{
if (!manager.window)
ssl_manager_create();
manage_window_set_transient(GTK_WINDOW(manager.window));
gtk_widget_grab_focus(manager.close_btn);
ssl_manager_load_certs();
gtk_widget_show(manager.window);
}
void prefs_display_header_open(void)
{
if (!dispheader.window) {
prefs_display_header_create();
}
gtkut_box_set_reverse_order(GTK_BOX(dispheader.confirm_area),
!prefs_common.comply_gnome_hig);
manage_window_set_transient(GTK_WINDOW(dispheader.window));
gtk_widget_grab_focus(dispheader.ok_btn);
prefs_display_header_set_dialog();
gtk_widget_show(dispheader.window);
}
void prefs_actions_open(MainWindow *mainwin)
{
inc_lock();
if (!actions.window)
prefs_actions_create(mainwin);
manage_window_set_transient(GTK_WINDOW(actions.window));
gtk_widget_grab_focus(actions.ok_btn);
prefs_actions_set_dialog();
gtk_widget_show(actions.window);
gtk_window_set_modal(GTK_WINDOW(actions.window), TRUE);
}
GSList *grouplist_dialog(Folder *folder)
{
GNode *node;
FolderItem *item;
if (dialog && gtk_widget_get_visible(dialog)) return NULL;
if (!dialog)
grouplist_dialog_create();
news_folder = folder;
gtk_widget_show(dialog);
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
manage_window_set_transient(GTK_WINDOW(dialog));
gtk_widget_grab_focus(ok_button);
gtk_widget_grab_focus(ctree);
GTK_EVENTS_FLUSH();
subscribed = NULL;
for (node = folder->node->children; node != NULL; node = node->next) {
item = FOLDER_ITEM(node->data);
subscribed = g_slist_append(subscribed, g_strdup(item->path));
}
grouplist_dialog_set_list(NULL, TRUE);
if (ack) gtk_main();
manage_window_focus_out(dialog, NULL, NULL);
gtk_widget_hide(dialog);
if (!ack) {
slist_free_strings_full(subscribed);
subscribed = NULL;
for (node = folder->node->children; node != NULL;
node = node->next) {
item = FOLDER_ITEM(node->data);
subscribed = g_slist_append(subscribed,
g_strdup(item->path));
}
}
grouplist_clear();
return subscribed;
}
void prefs_custom_header_open(PrefsAccount *ac)
{
if (!customhdr.window) {
prefs_custom_header_create();
}
manage_window_set_transient(GTK_WINDOW(customhdr.window));
gtk_widget_grab_focus(customhdr.ok_btn);
prefs_custom_header_set_dialog(ac);
cur_ac = ac;
gtk_widget_show(customhdr.window);
gtk_window_set_modal(GTK_WINDOW(customhdr.window), TRUE);
}
void prefs_display_header_open(void)
{
if (prefs_rc_is_readonly(DISPLAY_HEADER_RC))
return;
if (!dispheader.window) {
prefs_display_header_create();
}
manage_window_set_transient(GTK_WINDOW(dispheader.window));
gtk_widget_grab_focus(dispheader.ok_btn);
prefs_display_header_set_dialog();
gtk_widget_show(dispheader.window);
gtk_window_set_modal(GTK_WINDOW(dispheader.window), TRUE);
}
void prefs_summary_open_open(void)
{
int i;
if (!summaryopen.window) {
prefs_summary_open_create();
}
manage_window_set_transient(GTK_WINDOW(summaryopen.window));
gtk_widget_grab_focus(summaryopen.ok_btn);
prefs_summary_open_set_dialog();
for (i = 0; i < SUMMARY_OPEN_ACTIONS-1; i++)
saved_summary_select_prio[i] = prefs_common.summary_select_prio[i];
gtk_widget_show(summaryopen.window);
gtk_window_set_modal(GTK_WINDOW(summaryopen.window), TRUE);
}
static SendProgressDialog *send_progress_dialog_create(void)
{
SendProgressDialog *dialog;
ProgressDialog *progress;
static GdkGeometry geometry;
dialog = g_new0(SendProgressDialog, 1);
progress = progress_dialog_create();
gtk_window_set_title(GTK_WINDOW(progress->window),
_("Sending message"));
g_signal_connect(G_OBJECT(progress->showlog_btn), "clicked",
G_CALLBACK(send_showlog_button_cb), dialog);
g_signal_connect(G_OBJECT(progress->cancel_btn), "clicked",
G_CALLBACK(send_cancel_button_cb), dialog);
g_signal_connect(G_OBJECT(progress->window), "delete_event",
G_CALLBACK(gtk_true), NULL);
gtk_window_set_modal(GTK_WINDOW(progress->window), TRUE);
g_signal_connect(G_OBJECT(progress->window), "size_allocate",
G_CALLBACK(send_progress_dialog_size_allocate_cb), NULL);
manage_window_set_transient(GTK_WINDOW(progress->window));
progress_dialog_get_fraction(progress);
if (!geometry.min_height) {
geometry.min_width = 460;
geometry.min_height = 250;
}
gtk_window_set_geometry_hints(GTK_WINDOW(progress->window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
gtk_widget_set_size_request(progress->window, prefs_common.sendwin_width,
prefs_common.sendwin_height);
if (!prefs_common.send_dialog_invisible) {
gtk_widget_show_now(progress->window);
}
dialog->dialog = progress;
return dialog;
}
static void alertpanel_show(void)
{
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
manage_window_set_transient(GTK_WINDOW(dialog));
gtk_widget_show_all(dialog);
value = G_ALERTWAIT;
if (gdk_pointer_is_grabbed())
gdk_pointer_ungrab(GDK_CURRENT_TIME);
inc_lock();
while ((value & G_ALERT_VALUE_MASK) == G_ALERTWAIT)
gtk_main_iteration();
gtk_widget_destroy(dialog);
GTK_EVENTS_FLUSH();
alertpanel_is_open = FALSE;
hooks_invoke(ALERTPANEL_OPENED_HOOKLIST, &alertpanel_is_open);
inc_unlock();
}
void prefs_summary_column_open(void)
{
inc_lock();
if (!summary_col.window)
prefs_summary_column_create();
manage_window_set_transient(GTK_WINDOW(summary_col.window));
gtk_widget_grab_focus(summary_col.ok_btn);
prefs_summary_column_set_dialog(NULL);
gtk_widget_show(summary_col.window);
summary_col.finished = FALSE;
while (summary_col.finished == FALSE)
gtk_main_iteration();
gtk_widget_hide(summary_col.window);
inc_unlock();
}
gint import_mbox(FolderItem *default_dest)
/* return values: -2 skipped/cancelled, -1 error, 0 OK */
{
gchar *dest_id = NULL;
import_ok = -2; // skipped or cancelled
if (!window) {
import_create();
}
else {
gtk_widget_show(window);
}
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
change_dir(claws_get_startup_dir());
if (default_dest && default_dest->path) {
dest_id = folder_item_get_identifier(default_dest);
}
if (dest_id) {
gtk_entry_set_text(GTK_ENTRY(dest_entry), dest_id);
g_free(dest_id);
} else {
gtk_entry_set_text(GTK_ENTRY(dest_entry), "");
}
gtk_entry_set_text(GTK_ENTRY(file_entry), "");
gtk_widget_grab_focus(file_entry);
manage_window_set_transient(GTK_WINDOW(window));
gtk_main();
gtk_widget_hide(window);
gtk_window_set_modal(GTK_WINDOW(window), FALSE);
return import_ok;
}
/**
* Process export address dialog.
* \param cache Address book/data source cache.
*/
void addressbook_exp_ldif( AddressCache *cache ) {
/* Set references to control data */
_addressCache_ = cache;
_exportCtl_ = exportldif_create();
exportldif_load_settings( _exportCtl_ );
/* Setup GUI */
if( ! expldif_dlg.window )
export_ldif_create();
gtk_button_set_label(GTK_BUTTON(expldif_dlg.btnCancel),
GTK_STOCK_CANCEL);
expldif_dlg.cancelled = FALSE;
gtk_widget_show(expldif_dlg.window);
manage_window_set_transient(GTK_WINDOW(expldif_dlg.window));
gtk_window_set_modal(GTK_WINDOW(expldif_dlg.window), TRUE);
gtk_label_set_text( GTK_LABEL(expldif_dlg.labelBook), cache->name );
gtk_label_set_text( GTK_LABEL(expldif_dlg.labelOutBook), cache->name );
export_ldif_fill_fields( _exportCtl_ );
gtk_widget_grab_default(expldif_dlg.btnNext);
gtk_notebook_set_current_page( GTK_NOTEBOOK(expldif_dlg.notebook), PAGE_FILE_INFO );
gtk_widget_set_sensitive( expldif_dlg.btnPrev, FALSE );
gtk_widget_set_sensitive( expldif_dlg.btnNext, TRUE );
export_ldif_message();
gtk_widget_grab_focus(expldif_dlg.entryLdif);
gtk_main();
gtk_widget_hide(expldif_dlg.window);
gtk_window_set_modal(GTK_WINDOW(expldif_dlg.window), FALSE);
exportldif_free( _exportCtl_ );
_exportCtl_ = NULL;
_addressCache_ = NULL;
}
/* Callback for selecting folders. If no selection dialog exists yet, create
* one and initialize the selection. The recurse through the whole model, and
* add all selected items to the list. */
static void folder_checked(guint id)
{
SpecificFolderArrayEntry *entry;
GSList *checked_list = NULL;
entry = foldercheck_get_entry_from_id(id);
/* Create window */
foldercheck_create_window(entry);
gtk_widget_show(entry->window);
manage_window_set_transient(GTK_WINDOW(entry->window));
entry->cancelled = entry->finished = FALSE;
while(entry->finished == FALSE)
gtk_main_iteration();
foldercheck_destroy_window(entry);
if(!entry->cancelled) {
/* recurse through the whole model, add all selected items to the list */
gtk_tree_model_foreach(GTK_TREE_MODEL(entry->tree_store),
foldercheck_foreach_check, &checked_list);
if(entry->list) {
g_slist_free(entry->list);
entry->list = NULL;
}
entry->list = g_slist_copy(checked_list);
g_slist_free(checked_list);
}
gtk_tree_store_clear(entry->tree_store);
entry->cancelled = FALSE;
entry->finished = FALSE;
}
AdapterDSource *addressbook_edit_book( AddressIndex *addrIndex, AdapterDSource *ads ) {
static gboolean cancelled;
gchar *sName;
AddressDataSource *ds = NULL;
AddressBookFile *abf;
gboolean fin;
gboolean newBook = FALSE;
gchar *newFile = NULL;
if (!addrbookedit_dlg.window)
addressbook_edit_book_create(&cancelled);
gtk_widget_grab_focus(addrbookedit_dlg.ok_btn);
gtk_widget_grab_focus(addrbookedit_dlg.name_entry);
gtk_widget_show(addrbookedit_dlg.window);
manage_window_set_transient(GTK_WINDOW(addrbookedit_dlg.window));
gtk_window_set_modal(GTK_WINDOW(addrbookedit_dlg.window), TRUE);
edit_book_status_show( "" );
gtk_label_set_text( GTK_LABEL(addrbookedit_dlg.file_label), "" );
if( ads ) {
ds = ads->dataSource;
abf = ds->rawDataSource;
if ( addrbook_get_name( abf ) )
gtk_entry_set_text(GTK_ENTRY(addrbookedit_dlg.name_entry),
addrbook_get_name( abf ) );
if( abf->fileName )
gtk_label_set_text(GTK_LABEL(addrbookedit_dlg.file_label), abf->fileName);
gtk_window_set_title( GTK_WINDOW(addrbookedit_dlg.window), _("Edit Addressbook"));
edit_book_enable_buttons( TRUE );
}
else {
gchar *tmp = NULL;
newBook = TRUE;
abf = addrbook_create_book();
addrbook_set_path( abf, addrIndex->filePath );
/* Take initial guess at file name */
newFile = addrbook_guess_next_file( abf );
if( newFile ) {
tmp = g_strdup_printf( "<%s>", newFile );
gtk_label_set_text(GTK_LABEL(addrbookedit_dlg.file_label), tmp );
g_free( tmp );
}
g_free( newFile );
gtk_entry_set_text( GTK_ENTRY(addrbookedit_dlg.name_entry), ADDRESSBOOK_GUESS_BOOK );
gtk_window_set_title( GTK_WINDOW(addrbookedit_dlg.window), _("Add New Addressbook") );
edit_book_enable_buttons( FALSE );
}
addrbookedit_dlg.bookFile = abf;
gtk_main();
gtk_widget_hide(addrbookedit_dlg.window);
gtk_window_set_modal(GTK_WINDOW(addrbookedit_dlg.window), FALSE);
if( cancelled == TRUE ) {
if( newBook ) {
addrbook_free_book( abf );
abf = NULL;
}
return NULL;
}
fin = FALSE;
sName = gtk_editable_get_chars( GTK_EDITABLE(addrbookedit_dlg.name_entry), 0, -1 );
if( *sName == '\0' ) fin = TRUE;
if( fin ) {
if( newBook ) {
addrbook_free_book( abf );
abf = NULL;
}
}
else {
if( newBook ) {
/* Get final file name in case it changed */
newFile = addrbook_guess_next_file( abf );
addrbook_set_file( abf, newFile );
g_free( newFile );
ds = addrindex_index_add_datasource( addrIndex, ADDR_IF_BOOK, abf );
ads = addressbook_create_ds_adapter( ds, ADDR_BOOK, NULL );
}
addressbook_ads_set_name( ads, sName );
addrbook_set_name( abf, sName );
}
g_free( sName );
/* Save data */
if( abf ) addrbook_save_data( abf );
return ads;
}
static void alertpanel_create(const gchar *title,
const gchar *message,
AlertType type,
AlertValue default_value,
gboolean can_disable,
const gchar *button1_label,
const gchar *button2_label,
const gchar *button3_label)
{
static PangoFontDescription *font_desc;
GtkWidget *image;
GtkWidget *label;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *disable_chkbtn;
GtkWidget *confirm_area;
GtkWidget *button1;
GtkWidget *button2;
GtkWidget *button3;
const gchar *label2;
const gchar *label3;
debug_print(_("Creating alert panel dialog...\n"));
dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog), title);
gtk_window_set_policy(GTK_WINDOW(dialog), FALSE, FALSE, FALSE);
gtk_window_set_position(GTK_WINDOW(dialog),
GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
manage_window_set_transient(GTK_WINDOW(dialog));
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_widget_realize(dialog);
g_signal_connect(G_OBJECT(dialog), "delete_event",
G_CALLBACK(alertpanel_deleted),
(gpointer)G_ALERTCANCEL);
g_signal_connect(G_OBJECT(dialog), "key_press_event",
G_CALLBACK(alertpanel_close),
(gpointer)G_ALERTCANCEL);
g_signal_connect(G_OBJECT(dialog), "focus_out_event",
G_CALLBACK(alertpanel_focus_out), NULL);
/* for title icon, label and message */
hbox = gtk_hbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 12);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),
hbox, FALSE, FALSE, 0);
/* title icon */
switch (type) {
case ALERT_QUESTION:
image = gtk_image_new_from_stock
(GTK_STOCK_DIALOG_QUESTION, GTK_ICON_SIZE_DIALOG);
break;
case ALERT_WARNING:
image = gtk_image_new_from_stock
(GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
break;
case ALERT_ERROR:
image = gtk_image_new_from_stock
(GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG);
break;
case ALERT_NOTICE:
default:
image = gtk_image_new_from_stock
(GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
break;
}
gtk_misc_set_alignment(GTK_MISC(image), 0.5, 0.0);
gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
/* for title and message */
vbox = gtk_vbox_new(FALSE, 12);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
label = gtk_label_new(title);
gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
if (!font_desc) {
gint size;
size = pango_font_description_get_size
(label->style->font_desc);
font_desc = pango_font_description_new();
pango_font_description_set_weight
(font_desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_size
(font_desc, size * PANGO_SCALE_LARGE);
}
if (font_desc)
gtk_widget_modify_font(label, font_desc);
/* message label */
label = gtk_label_new(message);
gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
GTK_WIDGET_UNSET_FLAGS(label, GTK_CAN_FOCUS);
#ifdef G_OS_WIN32
{
GtkStyle *style;
style = gtk_widget_get_style(dialog);
gtk_widget_modify_base(label, GTK_STATE_ACTIVE,
&style->base[GTK_STATE_SELECTED]);
gtk_widget_modify_text(label, GTK_STATE_ACTIVE,
&style->text[GTK_STATE_SELECTED]);
}
#endif
if (can_disable) {
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 0);
disable_chkbtn = gtk_check_button_new_with_label
(_("Show this message next time"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(disable_chkbtn),
TRUE);
gtk_box_pack_start(GTK_BOX(hbox), disable_chkbtn,
FALSE, FALSE, 12);
g_signal_connect(G_OBJECT(disable_chkbtn), "toggled",
G_CALLBACK(alertpanel_button_toggled),
GUINT_TO_POINTER(G_ALERTDISABLE));
}
/* for button(s) */
if (!button1_label)
button1_label = GTK_STOCK_OK;
label2 = button2_label;
label3 = button3_label;
if (label2 && *label2 == '+') label2++;
if (label3 && *label3 == '+') label3++;
gtkut_stock_button_set_create(&confirm_area,
&button1, button1_label,
button2_label ? &button2 : NULL, label2,
button3_label ? &button3 : NULL, label3);
gtk_box_pack_end(GTK_BOX(GTK_DIALOG(dialog)->action_area),
confirm_area, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5);
gtk_widget_grab_default(button1);
gtk_widget_grab_focus(button1);
if (button2_label &&
(default_value == G_ALERTALTERNATE || *button2_label == '+')) {
gtk_widget_grab_default(button2);
gtk_widget_grab_focus(button2);
}
if (button3_label &&
(default_value == G_ALERTOTHER || *button3_label == '+')) {
gtk_widget_grab_default(button3);
gtk_widget_grab_focus(button3);
}
g_signal_connect(G_OBJECT(button1), "clicked",
G_CALLBACK(alertpanel_button_clicked),
GUINT_TO_POINTER(G_ALERTDEFAULT));
if (button2_label)
g_signal_connect(G_OBJECT(button2), "clicked",
G_CALLBACK(alertpanel_button_clicked),
GUINT_TO_POINTER(G_ALERTALTERNATE));
if (button3_label)
g_signal_connect(G_OBJECT(button3), "clicked",
G_CALLBACK(alertpanel_button_clicked),
GUINT_TO_POINTER(G_ALERTOTHER));
gtk_widget_show_all(dialog);
}
void pluginwindow_create()
{
PluginWindow *pluginwindow;
GtkWidget *window;
GtkWidget *vbox1;
GtkWidget *hbox2;
GtkWidget *scrolledwindow2;
GtkWidget *plugin_list_view;
GtkWidget *vbox2;
GtkWidget *frame2;
GtkWidget *label13;
GtkWidget *scrolledwindow3;
GtkWidget *plugin_desc;
GtkWidget *hbuttonbox1;
GtkWidget *hbuttonbox2;
GtkWidget *help_btn;
GtkWidget *load_btn;
GtkWidget *unload_btn;
GtkWidget *close_btn;
gchar *markup, *span;
GtkWidget *desc_lbl;
GtkWidget *vbox3;
GtkWidget *hbox_info;
static GdkGeometry geometry;
debug_print("Creating plugins window...\n");
pluginwindow = g_new0(PluginWindow, 1);
window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "pluginwindow");
gtk_container_set_border_width(GTK_CONTAINER(window), 8);
gtk_window_set_title(GTK_WINDOW(window), _("Plugins"));
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
manage_window_set_transient(GTK_WINDOW(window));
vbox1 = gtk_vbox_new(FALSE, 4);
gtk_widget_show(vbox1);
gtk_container_add(GTK_CONTAINER(window), vbox1);
gtk_box_set_homogeneous(GTK_BOX(vbox1), FALSE);
gtk_widget_realize(window);
hbox2 = gtk_hbox_new(FALSE, 8);
gtk_widget_show(hbox2);
gtk_box_pack_start(GTK_BOX(vbox1), hbox2, TRUE, TRUE, 0);
vbox3 = gtk_vbox_new(FALSE, 4);
gtk_widget_show(vbox3);
gtk_box_pack_start(GTK_BOX(hbox2), vbox3, FALSE, FALSE, 0);
scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow2);
gtk_box_pack_start(GTK_BOX(vbox3), scrolledwindow2, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow2),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW
(scrolledwindow2), GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
plugin_list_view = pluginwindow_list_view_create(pluginwindow);
gtk_widget_show(plugin_list_view);
gtk_container_add(GTK_CONTAINER(scrolledwindow2), plugin_list_view);
gtk_widget_grab_focus(GTK_WIDGET(plugin_list_view));
gtkut_stock_button_set_create(&hbuttonbox1,
&load_btn, _("_Load..."),
&unload_btn, _("_Unload"),
NULL, NULL);
gtk_widget_show(hbuttonbox1);
gtk_box_pack_start(GTK_BOX(vbox3), hbuttonbox1, FALSE, FALSE, 0);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox2);
gtk_box_pack_start(GTK_BOX(hbox2), vbox2, TRUE, TRUE, 0);
frame2 = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame2), GTK_SHADOW_OUT);
gtk_widget_show(frame2);
gtk_box_pack_start(GTK_BOX(vbox2), frame2, FALSE, TRUE, 0);
label13 = gtk_label_new(_("Description"));
gtk_widget_show(label13);
gtk_container_add(GTK_CONTAINER(frame2), label13);
gtk_misc_set_alignment(GTK_MISC(label13), 0, 0.5);
gtk_misc_set_padding(GTK_MISC(label13), 2, 2);
scrolledwindow3 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow3);
gtk_box_pack_start(GTK_BOX(vbox2), scrolledwindow3, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow3),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW
(scrolledwindow3), GTK_POLICY_NEVER,
GTK_POLICY_ALWAYS);
plugin_desc = gtk_text_view_new();
gtk_widget_show(plugin_desc);
gtk_container_add(GTK_CONTAINER(scrolledwindow3), plugin_desc);
hbox_info = gtk_hbox_new(FALSE, 5);
gtk_widget_show(hbox_info);
desc_lbl = gtk_label_new("");
span = g_strdup_printf("<a href=\"%s\"><span underline=\"none\">", PLUGINS_URI);
markup = g_strdup_printf(_("For more information about plugins see the "
"%sClaws Mail website%s."), span, "</span></a>");
gtk_label_set_markup(GTK_LABEL(desc_lbl), markup);
g_free(markup);
g_free(span);
gtk_misc_set_alignment(GTK_MISC(desc_lbl), 0, 0.5);
gtk_widget_show(desc_lbl);
gtk_box_pack_start(GTK_BOX(hbox_info), desc_lbl, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_info), gtk_label_new(""), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox1), hbox_info, FALSE, FALSE, 0);
gtkut_stock_button_set_create_with_help(&hbuttonbox2, &help_btn,
&close_btn, GTK_STOCK_CLOSE,
NULL, NULL, NULL, NULL);
gtk_box_set_spacing(GTK_BOX(hbuttonbox2), 6);
gtk_widget_show(hbuttonbox2);
gtk_box_pack_end(GTK_BOX(vbox1), hbuttonbox2, FALSE, FALSE, 0);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(plugin_desc), GTK_WRAP_WORD);
gtk_widget_set_sensitive(GTK_WIDGET(unload_btn), FALSE);
g_signal_connect(G_OBJECT(help_btn), "clicked",
G_CALLBACK(manual_open_with_anchor_cb),
MANUAL_ANCHOR_PLUGINS);
g_signal_connect(G_OBJECT(load_btn), "clicked",
G_CALLBACK(load_cb), pluginwindow);
g_signal_connect(G_OBJECT(unload_btn), "clicked",
G_CALLBACK(unload_cb), pluginwindow);
g_signal_connect(G_OBJECT(close_btn), "clicked",
G_CALLBACK(close_cb), pluginwindow);
g_signal_connect(G_OBJECT(window), "size_allocate",
G_CALLBACK(pluginwindow_size_allocate_cb), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(pluginwindow_key_pressed), pluginwindow);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(pluginwindow_delete_cb), pluginwindow);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
CLAWS_SET_TIP(load_btn,
_("Click here to load one or more plugins"));
CLAWS_SET_TIP(unload_btn,
_("Unload the selected plugin"));
pluginwindow->window = window;
pluginwindow->plugin_list_view = plugin_list_view;
pluginwindow->plugin_desc = plugin_desc;
pluginwindow->unload_btn = unload_btn;
pluginwindow->selected_plugin = NULL;
set_plugin_list(pluginwindow);
inc_lock();
if (!geometry.min_height) {
geometry.min_width = -1;
geometry.min_height = 300;
}
gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
gtk_window_set_default_size(GTK_WINDOW(window), prefs_common.pluginswin_width,
prefs_common.pluginswin_height);
gtk_widget_show(window);
}
static GtkWidget *date_format_create(GtkButton *button, void *data)
{
static GtkWidget *datefmt_win = NULL;
GtkWidget *vbox1;
GtkWidget *scrolledwindow1;
GtkWidget *datefmt_list_view;
GtkWidget *table;
GtkWidget *label1;
GtkWidget *label2;
GtkWidget *label3;
GtkWidget *confirm_area;
GtkWidget *ok_btn;
GtkWidget *cancel_btn;
GtkWidget *datefmt_entry;
GtkListStore *store;
struct {
gchar *fmt;
gchar *txt;
} time_format[] = {
{ "%a", NULL },
{ "%A", NULL },
{ "%b", NULL },
{ "%B", NULL },
{ "%c", NULL },
{ "%C", NULL },
{ "%d", NULL },
{ "%H", NULL },
{ "%I", NULL },
{ "%j", NULL },
{ "%m", NULL },
{ "%M", NULL },
{ "%p", NULL },
{ "%S", NULL },
{ "%w", NULL },
{ "%x", NULL },
{ "%y", NULL },
{ "%Y", NULL },
{ "%Z", NULL }
};
gint i;
const gint TIME_FORMAT_ELEMS =
sizeof time_format / sizeof time_format[0];
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
time_format[0].txt = _("the abbreviated weekday name");
time_format[1].txt = _("the full weekday name");
time_format[2].txt = _("the abbreviated month name");
time_format[3].txt = _("the full month name");
time_format[4].txt = _("the preferred date and time for the current locale");
time_format[5].txt = _("the century number (year/100)");
time_format[6].txt = _("the day of the month as a decimal number");
time_format[7].txt = _("the hour as a decimal number using a 24-hour clock");
time_format[8].txt = _("the hour as a decimal number using a 12-hour clock");
time_format[9].txt = _("the day of the year as a decimal number");
time_format[10].txt = _("the month as a decimal number");
time_format[11].txt = _("the minute as a decimal number");
time_format[12].txt = _("either AM or PM");
time_format[13].txt = _("the second as a decimal number");
time_format[14].txt = _("the day of the week as a decimal number");
time_format[15].txt = _("the preferred date for the current locale");
time_format[16].txt = _("the last two digits of a year");
time_format[17].txt = _("the year as a decimal number");
time_format[18].txt = _("the time zone or name or abbreviation");
if (datefmt_win) return datefmt_win;
store = gtk_list_store_new(N_DATEFMT_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
-1);
for (i = 0; i < TIME_FORMAT_ELEMS; i++) {
GtkTreeIter iter;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
DATEFMT_FMT, time_format[i].fmt,
DATEFMT_TXT, time_format[i].txt,
-1);
}
datefmt_win = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefs_summaries");
gtk_container_set_border_width(GTK_CONTAINER(datefmt_win), 8);
gtk_window_set_title(GTK_WINDOW(datefmt_win), _("Date format"));
gtk_window_set_position(GTK_WINDOW(datefmt_win), GTK_WIN_POS_CENTER);
gtk_widget_set_size_request(datefmt_win, 440, 280);
vbox1 = gtk_vbox_new(FALSE, 10);
gtk_widget_show(vbox1);
gtk_container_add(GTK_CONTAINER(datefmt_win), vbox1);
scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy
(GTK_SCROLLED_WINDOW(scrolledwindow1),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show(scrolledwindow1);
gtk_box_pack_start(GTK_BOX(vbox1), scrolledwindow1, TRUE, TRUE, 0);
datefmt_list_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(G_OBJECT(store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(datefmt_list_view),
prefs_common.use_stripes_everywhere);
gtk_widget_show(datefmt_list_view);
gtk_container_add(GTK_CONTAINER(scrolledwindow1), datefmt_list_view);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes
(_("Specifier"), renderer, "text", DATEFMT_FMT,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(datefmt_list_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes
(_("Description"), renderer, "text", DATEFMT_TXT,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(datefmt_list_view), column);
/* gtk_cmclist_set_column_width(GTK_CMCLIST(datefmt_clist), 0, 80); */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(datefmt_list_view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(datefmt_list_view), "row_activated",
G_CALLBACK(date_format_select_row),
datefmt_win);
table = gtk_table_new(2, 2, FALSE);
gtk_widget_show(table);
gtk_box_pack_start(GTK_BOX(vbox1), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 4);
gtk_table_set_col_spacings(GTK_TABLE(table), 8);
label1 = gtk_label_new(_("Date format"));
gtk_widget_show(label1);
gtk_table_attach(GTK_TABLE(table), label1, 0, 1, 0, 1,
GTK_FILL, 0, 0, 0);
gtk_label_set_justify(GTK_LABEL(label1), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(label1), 0, 0.5);
datefmt_entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(datefmt_entry), 256);
gtk_widget_show(datefmt_entry);
gtk_table_attach(GTK_TABLE(table), datefmt_entry, 1, 2, 0, 1,
(GTK_EXPAND | GTK_FILL), 0, 0, 0);
/* we need the "sample" entry box; add it as data so callbacks can
* get the entry box */
g_object_set_data(G_OBJECT(datefmt_win), "datefmt_sample",
datefmt_entry);
label2 = gtk_label_new(_("Example"));
gtk_widget_show(label2);
gtk_table_attach(GTK_TABLE(table), label2, 0, 1, 1, 2,
GTK_FILL, 0, 0, 0);
gtk_label_set_justify(GTK_LABEL(label2), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(label2), 0, 0.5);
label3 = gtk_label_new("");
gtk_widget_show(label3);
gtk_table_attach(GTK_TABLE(table), label3, 1, 2, 1, 2,
(GTK_EXPAND | GTK_FILL), 0, 0, 0);
gtk_label_set_justify(GTK_LABEL(label3), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(label3), 0, 0.5);
gtkut_stock_button_set_create(&confirm_area, &cancel_btn, GTK_STOCK_CANCEL,
&ok_btn, GTK_STOCK_OK, NULL, NULL);
gtk_box_pack_start(GTK_BOX(vbox1), confirm_area, FALSE, FALSE, 0);
gtk_widget_show(confirm_area);
gtk_widget_grab_default(ok_btn);
/* set the current format */
gtk_entry_set_text(GTK_ENTRY(datefmt_entry), prefs_common.date_format);
date_format_entry_on_change(GTK_EDITABLE(datefmt_entry),
GTK_LABEL(label3));
g_signal_connect(G_OBJECT(ok_btn), "clicked",
G_CALLBACK(date_format_ok_btn_clicked),
&datefmt_win);
g_signal_connect(G_OBJECT(cancel_btn), "clicked",
G_CALLBACK(date_format_cancel_btn_clicked),
&datefmt_win);
g_signal_connect(G_OBJECT(datefmt_win), "key_press_event",
G_CALLBACK(date_format_key_pressed),
&datefmt_win);
g_signal_connect(G_OBJECT(datefmt_win), "delete_event",
G_CALLBACK(date_format_on_delete),
&datefmt_win);
g_signal_connect(G_OBJECT(datefmt_entry), "changed",
G_CALLBACK(date_format_entry_on_change),
label3);
gtk_window_set_position(GTK_WINDOW(datefmt_win), GTK_WIN_POS_CENTER);
gtk_widget_show(datefmt_win);
manage_window_set_transient(GTK_WINDOW(datefmt_win));
gtk_window_set_modal(GTK_WINDOW(datefmt_win), TRUE);
gtk_widget_grab_focus(ok_btn);
return datefmt_win;
}
static gchar*
passphrase_mbox(const gchar *uid_hint, const gchar *pass_hint, gint prev_bad)
{
gchar *the_passphrase = NULL;
GtkWidget *vbox;
GtkWidget *confirm_box;
GtkWidget *window;
GtkWidget *pass_entry;
GtkWidget *ok_button;
GtkWidget *cancel_button;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), _("Passphrase"));
gtk_widget_set_size_request(window, 450, -1);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(window), TRUE);
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(passphrase_deleted), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(passphrase_key_pressed), NULL);
MANAGE_WINDOW_SIGNALS_CONNECT(window);
manage_window_set_transient(GTK_WINDOW(window));
vbox = gtk_vbox_new(FALSE, 8);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
if (uid_hint || pass_hint) {
GtkWidget *label;
label = create_description (uid_hint, pass_hint, prev_bad);
gtk_box_pack_start (GTK_BOX(vbox), label, FALSE, FALSE, 0);
}
pass_entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox), pass_entry, FALSE, FALSE, 0);
gtk_entry_set_visibility(GTK_ENTRY(pass_entry), FALSE);
gtk_widget_grab_focus(pass_entry);
gtkut_stock_button_set_create(&confirm_box, &ok_button, GTK_STOCK_OK,
&cancel_button, GTK_STOCK_CANCEL,
NULL, NULL);
gtk_box_pack_end(GTK_BOX(vbox), confirm_box, FALSE, FALSE, 0);
gtk_widget_grab_default(ok_button);
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(passphrase_ok_cb), NULL);
g_signal_connect(G_OBJECT(pass_entry), "activate",
G_CALLBACK(passphrase_ok_cb), NULL);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(passphrase_cancel_cb), NULL);
gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
if (grab_all)
gtk_window_set_policy (GTK_WINDOW(window), FALSE, FALSE, TRUE);
gtk_widget_show_all(window);
if (grab_all) {
/* make sure that window is viewable
* FIXME: this is still not enough */
gtk_widget_show_now(window);
gdk_flush();
#ifdef GDK_WINDOWING_X11
gdk_x11_display_grab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
if (gdk_pointer_grab(window->window, TRUE, 0,
window->window, NULL, GDK_CURRENT_TIME)) {
#ifdef GDK_WINDOWING_X11
gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
g_warning("OOPS: Could not grab mouse\n");
gtk_widget_destroy(window);
return NULL;
}
if (gdk_keyboard_grab(window->window, FALSE, GDK_CURRENT_TIME)) {
gdk_display_pointer_ungrab(gdk_display_get_default(),
GDK_CURRENT_TIME);
#ifdef GDK_WINDOWING_X11
gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
g_warning("OOPS: Could not grab keyboard\n");
gtk_widget_destroy(window);
return NULL;
}
}
gtk_main();
if (grab_all) {
gdk_display_keyboard_ungrab(gdk_display_get_default(),
GDK_CURRENT_TIME);
gdk_display_pointer_ungrab(gdk_display_get_default(), GDK_CURRENT_TIME);
#ifdef GDK_WINDOWING_X11
gdk_x11_display_ungrab(gdk_display_get_default());
#endif /* GDK_WINDOWING_X11 */
gdk_flush();
}
manage_window_focus_out(window, NULL, NULL);
if (pass_ack) {
const gchar *entry_text;
entry_text = gtk_entry_get_text(GTK_ENTRY(pass_entry));
the_passphrase = g_locale_from_utf8(entry_text, -1, NULL, NULL, NULL);
if (!the_passphrase)
the_passphrase = g_strdup(entry_text);
}
gtk_widget_destroy(window);
return the_passphrase;
}
AdapterDSource *addressbook_edit_jpilot( AddressIndex *addrIndex, AdapterDSource *ads ) {
static gboolean cancelled;
gchar *sName;
gchar *sFile;
gchar *sFSFile;
AddressDataSource *ds = NULL;
JPilotFile *jpf = NULL;
gboolean fin;
if( ! jpilotedit.window )
addressbook_edit_jpilot_create(&cancelled);
gtkut_box_set_reverse_order(GTK_BOX(jpilotedit.hbbox),
!prefs_common.comply_gnome_hig);
gtk_widget_grab_focus(jpilotedit.ok_btn);
gtk_widget_grab_focus(jpilotedit.name_entry);
gtk_widget_show(jpilotedit.window);
manage_window_set_transient(GTK_WINDOW(jpilotedit.window));
edit_jpilot_status_show( "" );
if( ads ) {
ds = ads->dataSource;
jpf = ds->rawDataSource;
if (jpf->name)
gtk_entry_set_text(GTK_ENTRY(jpilotedit.name_entry), jpf->name);
if (jpf->path)
gtk_entry_set_text(GTK_ENTRY(jpilotedit.file_entry), jpf->path);
gtk_window_set_title( GTK_WINDOW(jpilotedit.window), _("Edit JPilot Entry"));
edit_jpilot_fill_check_box( jpf );
}
else {
gchar *guessFile = jpilot_find_pilotdb();
gtk_entry_set_text(GTK_ENTRY(jpilotedit.name_entry), ADDRESSBOOK_GUESS_JPILOT );
gtk_entry_set_text(GTK_ENTRY(jpilotedit.file_entry), guessFile );
gtk_window_set_title( GTK_WINDOW(jpilotedit.window), _("Add New JPilot Entry"));
edit_jpilot_fill_check_box_new();
if( *guessFile != '\0' ) {
edit_jpilot_file_check();
}
}
gtk_main();
gtk_widget_hide(jpilotedit.window);
if (cancelled == TRUE) return NULL;
fin = FALSE;
sName = gtk_editable_get_chars( GTK_EDITABLE(jpilotedit.name_entry), 0, -1 );
sFile = gtk_editable_get_chars( GTK_EDITABLE(jpilotedit.file_entry), 0, -1 );
sFSFile = conv_filename_from_utf8( sFile );
if( *sName == '\0' ) fin = TRUE;
if( *sFile == '\0' ) fin = TRUE;
if( ! sFSFile || *sFSFile == '\0' ) fin = TRUE;
if( ! fin ) {
if( ! ads ) {
jpf = jpilot_create();
ds = addrindex_index_add_datasource( addrIndex, ADDR_IF_JPILOT, jpf );
ads = addressbook_create_ds_adapter( ds, ADDR_JPILOT, NULL );
}
addressbook_ads_set_name( ads, sName );
jpilot_set_name( jpf, sName );
jpilot_set_file( jpf, sFSFile );
edit_jpilot_read_check_box( jpf );
}
g_free( sFSFile );
g_free( sFile );
g_free( sName );
return ads;
}
void master_passphrase_change_dialog()
{
static PangoFontDescription *font_desc;
GtkWidget *dialog;
GtkWidget *vbox, *hbox;
GtkWidget *icon, *table, *label;
GtkWidget *msg_title;
GtkWidget *entry_old, *entry_new1, *entry_new2;
GtkWidget *confirm_area;
GtkWidget *ok_button, *cancel_button;
struct _ctx *ctx;
dialog = gtk_dialog_new();
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_window_set_default_size(GTK_WINDOW(dialog), 375, 100);
gtk_window_set_title(GTK_WINDOW(dialog), "");
MANAGE_WINDOW_SIGNALS_CONNECT(dialog);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_set_spacing(GTK_BOX(vbox), 14);
hbox = gtk_hbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION,
GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment(GTK_MISC(icon), 0.5, 0.0);
gtk_box_pack_start(GTK_BOX(hbox), icon, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 12);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show(vbox);
msg_title = gtk_label_new(_("Changing master passphrase"));
gtk_misc_set_alignment(GTK_MISC(msg_title), 0, 0.5);
gtk_label_set_justify(GTK_LABEL(msg_title), GTK_JUSTIFY_LEFT);
gtk_label_set_use_markup (GTK_LABEL (msg_title), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), msg_title, FALSE, FALSE, 0);
gtk_label_set_line_wrap(GTK_LABEL(msg_title), TRUE);
if (!font_desc) {
gint size;
size = pango_font_description_get_size
(gtk_widget_get_style(msg_title)->font_desc);
font_desc = pango_font_description_new();
pango_font_description_set_weight
(font_desc, PANGO_WEIGHT_BOLD);
pango_font_description_set_size
(font_desc, size * PANGO_SCALE_LARGE);
}
if (font_desc)
gtk_widget_modify_font(msg_title, font_desc);
label = gtk_label_new(
_("If a master passphrase is currently active, it\n"
"needs to be entered.")
);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
table = gtk_table_new(4, 2, FALSE);
/* Old passphrase */
label = gtk_label_new(_("Old passphrase:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
entry_old = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry_old), FALSE);
gtk_table_attach(GTK_TABLE(table), entry_old, 1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
/* Separator */
gtk_table_attach(GTK_TABLE(table),
gtk_hseparator_new(), 0, 2, 1, 2,
GTK_FILL | GTK_EXPAND, 0, 0, 5);
/* New passphrase */
label = gtk_label_new(_("New passphrase:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
entry_new1 = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry_new1), FALSE);
gtk_table_attach(GTK_TABLE(table), entry_new1, 1, 2, 2, 3,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
/* New passphrase again */
label = gtk_label_new(_("Confirm passphrase:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
entry_new2 = gtk_entry_new();
gtk_entry_set_visibility(GTK_ENTRY(entry_new2), FALSE);
gtk_table_attach(GTK_TABLE(table), entry_new2, 1, 2, 3, 4,
GTK_FILL | GTK_EXPAND, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
/* Dialog buttons */
gtkut_stock_button_set_create(&confirm_area,
&cancel_button, GTK_STOCK_CANCEL,
&ok_button, GTK_STOCK_OK,
NULL, NULL);
gtk_box_pack_end(GTK_BOX(gtk_dialog_get_action_area(GTK_DIALOG(dialog))),
confirm_area, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(confirm_area), 5);
gtk_widget_grab_default(ok_button);
/* If no master passphrase is set, disable the "old passphrase" entry */
if (!master_passphrase_is_set())
gtk_widget_set_sensitive(entry_old, FALSE);
g_signal_connect(G_OBJECT(entry_old), "activate",
G_CALLBACK(entry_activated), entry_new1);
g_signal_connect(G_OBJECT(entry_new1), "activate",
G_CALLBACK(entry_activated), entry_new2);
gtk_entry_set_activates_default(GTK_ENTRY(entry_new2), TRUE);
ctx = g_new(struct _ctx, 1);
ctx->done = FALSE;
ctx->dialog = dialog;
ctx->entry_old = entry_old;
ctx->entry_new1 = entry_new1;
ctx->entry_new2 = entry_new2;
g_signal_connect(G_OBJECT(ok_button), "clicked",
G_CALLBACK(ok_button_clicked), ctx);
g_signal_connect(G_OBJECT(cancel_button), "clicked",
G_CALLBACK(cancel_button_clicked), ctx);
g_signal_connect(G_OBJECT(dialog), "destroy",
G_CALLBACK(dialog_destroy), ctx);
gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
gtk_window_present(GTK_WINDOW(dialog));
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
manage_window_set_transient(GTK_WINDOW(dialog));
while (!ctx->done)
gtk_main_iteration();
if (ctx->dialog != NULL)
gtk_widget_destroy(ctx->dialog);
GTK_EVENTS_FLUSH();
g_free(ctx);
}
