void CExpressDlg::Execute()
{
int res, id;
char msg[256], buf[256];
GtkTreeModel *pList = g_Project->FileList();
GtkTreeIter iter, iter2;
m_Updating = true;
// Default state
GtkTreeSelection *pSel = g_MainWnd->GetSelection();
gtk_widget_set_sensitive(m_SelBtn, gtk_tree_selection_count_selected_rows(pSel)>0);
m_Selected = gtk_tree_selection_count_selected_rows(pSel)>1;
if (m_Selected)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_SelBtn), true);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_AllBtn), true);
// Restore last settings
if (m_ConvertBtn) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_ConvertBtn),
g_Project->GetBool("ExpressReduction", "Convert", true));
CmpackChannel channel = (CmpackChannel)g_Project->GetInt("Convert", "ColorChannel", CMPACK_CHANNEL_DEFAULT);
SelectChannel(channel);
}
if (m_TimeCorrBtn) {
m_TimeCorr = g_Project->GetDbl("TimeCorr", "Seconds", 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_TimeCorrBtn),
g_Project->GetBool("ExpressReduction", "TimeCorr", false));
UpdateTimeCorrection();
}
if (m_BiasCorrBtn && m_BiasFrameEdit) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_BiasCorrBtn),
g_Project->GetBool("ExpressReduction", "BiasCorr", false));
char *bias = g_Project->GetStr("BiasCorr", "File", NULL);
if (bias)
gtk_entry_set_text(GTK_ENTRY(m_BiasFrameEdit), bias);
else
gtk_entry_set_text(GTK_ENTRY(m_BiasFrameEdit), "");
g_free(bias);
}
if (m_DarkCorrBtn && m_DarkFrameEdit) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_DarkCorrBtn),
g_Project->GetBool("ExpressReduction", "DarkCorr", false));
char *dark = g_Project->GetStr("DarkCorr", "File", NULL);
if (dark)
gtk_entry_set_text(GTK_ENTRY(m_DarkFrameEdit), dark);
else
gtk_entry_set_text(GTK_ENTRY(m_DarkFrameEdit), "");
g_free(dark);
}
if (m_FlatCorrBtn && m_FlatFrameEdit) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_FlatCorrBtn),
g_Project->GetBool("ExpressReduction", "FlatCorr", false));
char *flat = g_Project->GetStr("FlatCorr", "File", NULL);
if (flat)
gtk_entry_set_text(GTK_ENTRY(m_FlatFrameEdit), flat);
else
gtk_entry_set_text(GTK_ENTRY(m_FlatFrameEdit), "");
g_free(flat);
}
if (m_PhotometryBtn) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_PhotometryBtn),
g_Project->GetBool("ExpressReduction", "Photometry", false));
}
if (m_MatchingBtn && m_RefBtn && m_CatBtn) {
m_Matching = g_Project->GetBool("ExpressReduction", "Matching", false);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_MatchingBtn), m_Matching && !m_Selected);
if (g_Project->GetInt("MatchingDlg", "Select", 0)==0)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_RefBtn), true);
else
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_CatBtn), true);
}
if (m_RefFrameCombo) {
gtk_combo_box_set_model(GTK_COMBO_BOX(m_RefFrameCombo), NULL);
gtk_list_store_clear(m_Frames);
gboolean ok = gtk_tree_model_get_iter_first(pList, &iter);
while (ok) {
gtk_tree_model_get(GTK_TREE_MODEL(pList), &iter, FRAME_ID, &id, -1);
gtk_list_store_append(m_Frames, &iter2);
sprintf(buf, "Frame #%d", id);
gtk_list_store_set(m_Frames, &iter2, 0, id, 1, buf, -1);
ok = gtk_tree_model_iter_next(pList, &iter);
}
gtk_combo_box_set_model(GTK_COMBO_BOX(m_RefFrameCombo), GTK_TREE_MODEL(m_Frames));
SelectRefFrame(g_Project->GetInt("MatchingDlg", "Frame", 0));
if (gtk_combo_box_get_active(GTK_COMBO_BOX(m_RefFrameCombo))<0) {
GtkTreeIter iter3;
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(m_Frames), &iter3))
gtk_combo_box_set_active_iter(GTK_COMBO_BOX(m_RefFrameCombo), &iter3);
}
}
if (m_CatFrameEdit) {
char *path = g_Project->GetStr("MatchingDlg", "File", NULL);
if (path)
gtk_entry_set_text(GTK_ENTRY(m_CatFrameEdit), path);
else
gtk_entry_set_text(GTK_ENTRY(m_CatFrameEdit), "");
g_free(path);
}
m_Updating = false;
UpdateControls();
if (gtk_dialog_run(GTK_DIALOG(m_pDlg))!=GTK_RESPONSE_ACCEPT)
return;
gtk_widget_hide(m_pDlg);
// Save parameters
memset(&m_Params, 0, sizeof(tProcParams));
if (m_ConvertBtn) {
m_Params.Convert = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_ConvertBtn))!=0;
g_Project->SetBool("ExpressReduction", "Convert", m_Params.Convert);
g_Project->SetInt("Convert", "ColorChannel", SelectedChannel());
}
if (m_TimeCorrBtn) {
m_Params.TimeCorr = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_TimeCorrBtn))!=0;
g_Project->SetBool("ExpressReduction", "TimeCorr", m_Params.TimeCorr);
m_Params.Seconds = m_TimeCorr;
g_Project->SetDbl("TimeCorr", "Seconds", m_Params.Seconds);
}
if (m_BiasCorrBtn && m_BiasFrameEdit) {
m_Params.BiasCorr = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_BiasCorrBtn))!=0;
g_Project->SetBool("ExpressReduction", "BiasCorr", m_Params.BiasCorr);
m_Params.BiasFrame = gtk_entry_get_text(GTK_ENTRY(m_BiasFrameEdit));
g_Project->SetStr("BiasCorr", "File", m_Params.BiasFrame);
CConfig::SetStr("BiasCorr", "File", m_Params.BiasFrame);
}
if (m_DarkCorrBtn && m_DarkFrameEdit) {
m_Params.DarkCorr = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_DarkCorrBtn))!=0;
g_Project->SetBool("ExpressReduction", "DarkCorr", m_Params.DarkCorr);
m_Params.DarkFrame = gtk_entry_get_text(GTK_ENTRY(m_DarkFrameEdit));
g_Project->SetStr("DarkCorr", "File", m_Params.DarkFrame);
CConfig::SetStr("DarkCorr", "File", m_Params.DarkFrame);
}
if (m_FlatCorrBtn && m_FlatFrameEdit) {
m_Params.FlatCorr = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_FlatCorrBtn))!=0;
g_Project->SetBool("ExpressReduction", "FlatCorr", m_Params.FlatCorr);
m_Params.FlatFrame = gtk_entry_get_text(GTK_ENTRY(m_FlatFrameEdit));
g_Project->SetStr("FlatCorr", "File", m_Params.FlatFrame);
CConfig::SetStr("FlatCorr", "File", m_Params.FlatFrame);
}
if (m_PhotometryBtn) {
m_Params.Photometry = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_PhotometryBtn))!=0;
g_Project->SetBool("ExpressReduction", "Photometry", m_Params.Photometry);
}
if (m_MatchingBtn && m_RefBtn) {
m_Params.Matching = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_MatchingBtn))!=0;
g_Project->SetBool("ExpressReduction", "Matching", m_Matching);
m_Params.UseRef = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_RefBtn))!=0;
g_Project->SetInt("MatchingDlg", "Select", (m_Params.UseRef ? 0 : 1));
}
if (m_RefFrameCombo) {
m_Params.RefFrame = SelectedRefFrame();
g_Project->SetInt("MatchingDlg", "Frame", m_Params.RefFrame);
}
if (m_CatFrameEdit) {
m_Params.CatFile = gtk_entry_get_text(GTK_ENTRY(m_CatFrameEdit));
g_Project->SetStr("MatchingDlg", "File", m_Params.CatFile);
CConfig::SetStr("MatchingDlg", "File", m_Params.CatFile);
}
// Make list of unprocessed frames
if (!m_Selected) {
// All files
GtkTreeModel *pList = g_Project->FileList();
if (gtk_tree_model_iter_n_children(pList, NULL)>0)
gtk_tree_model_foreach(pList, foreach_all_files, &m_Params.FileList);
else
ShowError(m_pParent, "There are no files in the project.");
} else {
// Selected files
GtkTreeSelection *pSel = g_MainWnd->GetSelection();
if (gtk_tree_selection_count_selected_rows(pSel)>0)
gtk_tree_selection_selected_foreach(pSel, foreach_sel_files, &m_Params.FileList);
else
ShowError(m_pParent, "There are no selected files.");
}
if (m_Params.FileList) {
if (m_Params.Convert && !m_Selected) {
g_Project->ClearThumbnails();
g_Project->ClearTempFiles();
g_Project->ClearCorrections();
g_Project->ClearReference();
g_Project->ClearObject();
}
if (m_Params.Matching)
g_Project->ClearReference();
CProgressDlg pDlg(m_pParent, "Processing files");
pDlg.SetMinMax(0, g_list_length(m_Params.FileList));
res = pDlg.Execute(ExecuteProc, this);
if (res!=0) {
char *msg = cmpack_formaterror(res);
ShowError(m_pParent, msg, true);
cmpack_free(msg);
} else
if (m_Params.OutFiles==0) {
ShowError(m_pParent, "No file was successfully processed.", true);
} else
if (m_Params.OutFiles!=m_Params.InFiles) {
sprintf(msg, "%d file(s) were successfully processed, %d file(s) failed.",
m_Params.OutFiles, m_Params.InFiles-m_Params.OutFiles);
ShowWarning(m_pParent, msg, true);
} else {
sprintf(msg, "All %d file(s) were successfully processed.", m_Params.OutFiles);
ShowInformation(m_pParent, msg, true);
}
g_list_foreach(m_Params.FileList, (GFunc)gtk_tree_row_reference_free, NULL);
g_list_free(m_Params.FileList);
}
g_Project->Save();
}
void themes_init(AppearanceData* data)
{
GtkWidget *w, *del_button;
GList *theme_list, *l;
GtkListStore *theme_store;
GtkTreeModel *sort_model;
MateThemeMetaInfo *meta_theme = NULL;
GtkIconView *icon_view;
GtkCellRenderer *renderer;
GtkSettings *settings;
char *url;
/* initialise some stuff */
mate_theme_init ();
mate_wm_manager_init ();
data->revert_application_font = NULL;
data->revert_documents_font = NULL;
data->revert_desktop_font = NULL;
data->revert_windowtitle_font = NULL;
data->revert_monospace_font = NULL;
data->theme_save_dialog = NULL;
data->theme_message_area = NULL;
data->theme_info_icon = NULL;
data->theme_error_icon = NULL;
data->theme_custom = mate_theme_meta_info_new ();
data->theme_icon = gdk_pixbuf_new_from_file (MATECC_PIXMAP_DIR "/theme-thumbnailing.png", NULL);
data->theme_store = theme_store =
gtk_list_store_new (NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
/* set up theme list */
theme_list = mate_theme_meta_info_find_all ();
mate_theme_info_register_theme_change ((ThemeChangedCallback) theme_changed_on_disk_cb, data);
data->theme_custom = theme_load_from_mateconf (data->client);
data->theme_custom->name = g_strdup (CUSTOM_THEME_NAME);
data->theme_custom->readable_name = g_strdup_printf ("<i>%s</i>", _("Custom"));
for (l = theme_list; l; l = l->next) {
MateThemeMetaInfo *info = l->data;
gtk_list_store_insert_with_values (theme_store, NULL, 0,
COL_LABEL, info->readable_name,
COL_NAME, info->name,
COL_THUMBNAIL, data->theme_icon,
-1);
if (!meta_theme && theme_is_equal (data->theme_custom, info))
meta_theme = info;
}
if (!meta_theme) {
/* add custom theme */
meta_theme = data->theme_custom;
gtk_list_store_insert_with_values (theme_store, NULL, 0,
COL_LABEL, meta_theme->readable_name,
COL_NAME, meta_theme->name,
COL_THUMBNAIL, data->theme_icon,
-1);
theme_thumbnail_generate (meta_theme, data);
}
theme_list = g_list_sort (theme_list, (GCompareFunc) theme_list_sort_func);
g_list_foreach (theme_list, (GFunc) theme_thumbnail_generate, data);
g_list_free (theme_list);
icon_view = GTK_ICON_VIEW (appearance_capplet_get_widget (data, "theme_list"));
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "xpad", 5, "ypad", 5,
"xalign", 0.5, "yalign", 1.0, NULL);
gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (icon_view), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_view), renderer,
"pixbuf", COL_THUMBNAIL, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "alignment", PANGO_ALIGN_CENTER,
"wrap-mode", PANGO_WRAP_WORD_CHAR,
"wrap-width", gtk_icon_view_get_item_width (icon_view),
"width", gtk_icon_view_get_item_width (icon_view),
"xalign", 0.0, "yalign", 0.0, NULL);
gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (icon_view), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_view), renderer,
"markup", COL_LABEL, NULL);
sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (theme_store));
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), COL_LABEL, theme_store_sort_func, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model), COL_LABEL, GTK_SORT_ASCENDING);
gtk_icon_view_set_model (icon_view, GTK_TREE_MODEL (sort_model));
g_signal_connect (icon_view, "selection-changed", (GCallback) theme_selection_changed_cb, data);
g_signal_connect_after (icon_view, "realize", (GCallback) theme_select_name, meta_theme->name);
w = appearance_capplet_get_widget (data, "theme_install");
gtk_button_set_image (GTK_BUTTON (w),
gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON));
g_signal_connect (w, "clicked", (GCallback) theme_install_cb, data);
w = appearance_capplet_get_widget (data, "theme_save");
gtk_button_set_image (GTK_BUTTON (w),
gtk_image_new_from_stock (GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_BUTTON));
g_signal_connect (w, "clicked", (GCallback) theme_save_cb, data);
w = appearance_capplet_get_widget (data, "theme_custom");
gtk_button_set_image (GTK_BUTTON (w),
gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_BUTTON));
g_signal_connect (w, "clicked", (GCallback) theme_custom_cb, data);
del_button = appearance_capplet_get_widget (data, "theme_delete");
g_signal_connect (del_button, "clicked", (GCallback) theme_delete_cb, data);
w = appearance_capplet_get_widget (data, "theme_vbox");
gtk_drag_dest_set (w, GTK_DEST_DEFAULT_ALL,
drop_types, G_N_ELEMENTS (drop_types),
GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_MOVE);
g_signal_connect (w, "drag-data-received", (GCallback) theme_drag_data_received_cb, data);
if (is_locked_down (data->client))
gtk_widget_set_sensitive (w, FALSE);
w = appearance_capplet_get_widget (data, "more_themes_linkbutton");
url = mateconf_client_get_string (data->client, MORE_THEMES_URL_KEY, NULL);
if (url != NULL && url[0] != '\0') {
gtk_link_button_set_uri (GTK_LINK_BUTTON (w), url);
gtk_widget_show (w);
} else {
gtk_widget_hide (w);
}
g_free (url);
/* listen to mateconf changes, too */
mateconf_client_add_dir (data->client, "/apps/marco/general", MATECONF_CLIENT_PRELOAD_NONE, NULL);
mateconf_client_add_dir (data->client, "/desktop/mate/interface", MATECONF_CLIENT_PRELOAD_NONE, NULL);
mateconf_client_notify_add (data->client, MARCO_THEME_KEY, (MateConfClientNotifyFunc) theme_mateconf_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, CURSOR_THEME_KEY, (MateConfClientNotifyFunc) theme_mateconf_changed, data, NULL, NULL);
#ifdef HAVE_XCURSOR
mateconf_client_notify_add (data->client, CURSOR_SIZE_KEY, (MateConfClientNotifyFunc) theme_mateconf_changed, data, NULL, NULL);
#endif
mateconf_client_notify_add (data->client, BACKGROUND_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, APPLICATION_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, DOCUMENTS_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, DESKTOP_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, WINDOWTITLE_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
mateconf_client_notify_add (data->client, MONOSPACE_FONT_KEY, (MateConfClientNotifyFunc) background_or_font_changed, data, NULL, NULL);
settings = gtk_settings_get_default ();
g_signal_connect (settings, "notify::gtk-color-scheme", (GCallback) theme_setting_changed_cb, data);
g_signal_connect (settings, "notify::gtk-theme-name", (GCallback) theme_setting_changed_cb, data);
g_signal_connect (settings, "notify::gtk-icon-theme-name", (GCallback) theme_setting_changed_cb, data);
/* monitor individual font choice buttons, so
"revert font" option (if any) can be cleared */
w = appearance_capplet_get_widget (data, "application_font");
g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data);
w = appearance_capplet_get_widget (data, "document_font");
g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data);
w = appearance_capplet_get_widget (data, "desktop_font");
g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data);
w = appearance_capplet_get_widget (data, "window_title_font");
g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data);
w = appearance_capplet_get_widget (data, "monospace_font");
g_signal_connect (w, "font_set", (GCallback) custom_font_cb, data);
}
static void
mail_shell_view_execute_search (EShellView *shell_view)
{
EMailShellViewPrivate *priv;
EMailShellContent *mail_shell_content;
EMailShellSidebar *mail_shell_sidebar;
EShellWindow *shell_window;
EShellBackend *shell_backend;
EShellContent *shell_content;
EShellSidebar *shell_sidebar;
EShellSearchbar *searchbar;
EActionComboBox *combo_box;
EMailBackend *backend;
EMailSession *session;
ESourceRegistry *registry;
EMFolderTree *folder_tree;
GtkWidget *message_list;
EFilterRule *rule;
EMailReader *reader;
EMailView *mail_view;
CamelVeeFolder *search_folder;
CamelFolder *folder;
CamelService *service;
CamelStore *store;
GtkAction *action;
EMailLabelListStore *label_store;
GtkTreePath *path;
GtkTreeIter tree_iter;
GString *string;
GList *list, *iter;
GSList *search_strings = NULL;
const gchar *text;
gboolean valid;
gchar *query;
gchar *temp;
gchar *tag;
const gchar *use_tag;
gint value;
priv = E_MAIL_SHELL_VIEW_GET_PRIVATE (shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
shell_backend = e_shell_view_get_shell_backend (shell_view);
shell_content = e_shell_view_get_shell_content (shell_view);
shell_sidebar = e_shell_view_get_shell_sidebar (shell_view);
backend = E_MAIL_BACKEND (shell_backend);
session = e_mail_backend_get_session (backend);
mail_shell_content = E_MAIL_SHELL_CONTENT (shell_content);
mail_view = e_mail_shell_content_get_mail_view (mail_shell_content);
searchbar = e_mail_shell_content_get_searchbar (mail_shell_content);
mail_shell_sidebar = E_MAIL_SHELL_SIDEBAR (shell_sidebar);
folder_tree = e_mail_shell_sidebar_get_folder_tree (mail_shell_sidebar);
reader = E_MAIL_READER (mail_view);
folder = e_mail_reader_ref_folder (reader);
message_list = e_mail_reader_get_message_list (reader);
registry = e_mail_session_get_registry (session);
label_store = e_mail_ui_session_get_label_store (
E_MAIL_UI_SESSION (session));
action = ACTION (MAIL_SEARCH_SUBJECT_OR_ADDRESSES_CONTAIN);
value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
text = e_shell_searchbar_get_search_text (searchbar);
if (value == MAIL_SEARCH_ADVANCED || text == NULL || *text == '\0') {
if (value != MAIL_SEARCH_ADVANCED)
e_shell_view_set_search_rule (shell_view, NULL);
query = e_shell_view_get_search_query (shell_view);
if (!query)
query = g_strdup ("");
goto filter;
}
/* Replace variables in the selected rule with the
* current search text and extract a query string. */
g_return_if_fail (value >= 0 && value < MAIL_NUM_SEARCH_RULES);
rule = priv->search_rules[value];
/* Set the search rule in EShellView so that "Create
* Search Folder from Search" works for quick searches. */
e_shell_view_set_search_rule (shell_view, rule);
for (iter = rule->parts; iter != NULL; iter = iter->next) {
EFilterPart *part = iter->data;
EFilterElement *element = NULL;
if (strcmp (part->name, "subject") == 0)
element = e_filter_part_find_element (part, "subject");
else if (strcmp (part->name, "body") == 0)
element = e_filter_part_find_element (part, "word");
else if (strcmp (part->name, "sender") == 0)
element = e_filter_part_find_element (part, "sender");
else if (strcmp (part->name, "to") == 0)
element = e_filter_part_find_element (part, "recipient");
if (strcmp (part->name, "body") == 0) {
struct _camel_search_words *words;
gint ii;
words = camel_search_words_split ((guchar *) text);
for (ii = 0; ii < words->len; ii++)
search_strings = g_slist_prepend (
search_strings, g_strdup (
words->words[ii]->word));
camel_search_words_free (words);
}
if (element != NULL) {
EFilterInput *input = E_FILTER_INPUT (element);
e_filter_input_set_value (input, text);
}
}
string = g_string_sized_new (1024);
e_filter_rule_build_code (rule, string);
query = g_string_free (string, FALSE);
filter:
/* Apply selected filter. */
combo_box = e_shell_searchbar_get_filter_combo_box (searchbar);
value = e_action_combo_box_get_current_value (combo_box);
switch (value) {
case MAIL_FILTER_ALL_MESSAGES:
break;
case MAIL_FILTER_UNREAD_MESSAGES:
temp = g_strdup_printf (
"(and %s (match-all (not "
"(system-flag \"Seen\"))))", query);
g_free (query);
query = temp;
break;
case MAIL_FILTER_NO_LABEL:
string = g_string_sized_new (1024);
g_string_append_printf (
string, "(and %s (and ", query);
valid = gtk_tree_model_get_iter_first (
GTK_TREE_MODEL (label_store), &tree_iter);
while (valid) {
tag = e_mail_label_list_store_get_tag (
label_store, &tree_iter);
use_tag = tag;
if (g_str_has_prefix (use_tag, "$Label"))
use_tag += 6;
g_string_append_printf (
string, " (match-all (not (or "
"(= (user-tag \"label\") \"%s\") "
"(user-flag \"$Label%s\") "
"(user-flag \"%s\"))))",
use_tag, use_tag, use_tag);
g_free (tag);
valid = gtk_tree_model_iter_next (
GTK_TREE_MODEL (label_store),
&tree_iter);
}
g_string_append_len (string, "))", 2);
g_free (query);
query = g_string_free (string, FALSE);
break;
case MAIL_FILTER_READ_MESSAGES:
temp = g_strdup_printf (
"(and %s (match-all "
"(system-flag \"Seen\")))", query);
g_free (query);
query = temp;
break;
case MAIL_FILTER_LAST_5_DAYS_MESSAGES:
if (em_utils_folder_is_sent (registry, folder))
temp = g_strdup_printf (
"(and %s (match-all "
"(> (get-sent-date) "
"(- (get-current-date) 432000))))",
query);
else
temp = g_strdup_printf (
"(and %s (match-all "
"(> (get-received-date) "
"(- (get-current-date) 432000))))",
query);
g_free (query);
query = temp;
break;
case MAIL_FILTER_MESSAGES_WITH_ATTACHMENTS:
temp = g_strdup_printf (
"(and %s (match-all "
"(system-flag \"Attachments\")))", query);
g_free (query);
query = temp;
break;
case MAIL_FILTER_IMPORTANT_MESSAGES:
temp = g_strdup_printf (
"(and %s (match-all "
"(system-flag \"Flagged\")))", query);
g_free (query);
query = temp;
break;
case MAIL_FILTER_MESSAGES_NOT_JUNK:
temp = g_strdup_printf (
"(and %s (match-all (not "
"(system-flag \"junk\"))))", query);
g_free (query);
query = temp;
break;
default:
/* The action value also serves as a path for
* the label list store. That's why we number
* the label actions from zero. */
path = gtk_tree_path_new_from_indices (value, -1);
gtk_tree_model_get_iter (
GTK_TREE_MODEL (label_store),
&tree_iter, path);
gtk_tree_path_free (path);
tag = e_mail_label_list_store_get_tag (
label_store, &tree_iter);
use_tag = tag;
if (g_str_has_prefix (use_tag, "$Label"))
use_tag += 6;
temp = g_strdup_printf (
"(and %s (match-all (or "
"(= (user-tag \"label\") \"%s\") "
"(user-flag \"$Label%s\") "
"(user-flag \"%s\"))))",
query, use_tag, use_tag, use_tag);
g_free (tag);
g_free (query);
query = temp;
break;
}
/* Apply selected scope. */
combo_box = e_shell_searchbar_get_scope_combo_box (searchbar);
value = e_action_combo_box_get_current_value (combo_box);
switch (value) {
case MAIL_SCOPE_CURRENT_FOLDER:
goto execute;
case MAIL_SCOPE_CURRENT_ACCOUNT:
goto current_account;
case MAIL_SCOPE_ALL_ACCOUNTS:
goto all_accounts;
default:
g_warn_if_reached ();
goto execute;
}
all_accounts:
/* Prepare search folder for all accounts. */
/* If the search text is empty, cancel any
* account-wide searches still in progress. */
text = e_shell_searchbar_get_search_text (searchbar);
if (text == NULL || *text == '\0') {
CamelStore *selected_store = NULL;
gchar *selected_folder_name = NULL;
if (priv->search_account_all != NULL) {
g_object_unref (priv->search_account_all);
priv->search_account_all = NULL;
}
if (priv->search_account_cancel != NULL) {
g_cancellable_cancel (priv->search_account_cancel);
g_object_unref (priv->search_account_cancel);
priv->search_account_cancel = NULL;
}
/* Reset the message list to the current folder tree
* selection. This needs to happen synchronously to
* avoid search conflicts, so we can't just grab the
* folder URI and let the asynchronous callbacks run
* after we've already kicked off the search. */
em_folder_tree_get_selected (
folder_tree, &selected_store, &selected_folder_name);
if (selected_store != NULL && selected_folder_name != NULL) {
folder = camel_store_get_folder_sync (
selected_store, selected_folder_name,
CAMEL_STORE_FOLDER_INFO_FAST, NULL, NULL);
e_mail_reader_set_folder (reader, folder);
g_object_unref (folder);
}
g_clear_object (&selected_store);
g_free (selected_folder_name);
gtk_widget_set_sensitive (GTK_WIDGET (combo_box), TRUE);
goto execute;
}
search_folder = priv->search_account_all;
/* Skip the search if we already have the results. */
if (search_folder != NULL) {
const gchar *vf_query;
vf_query = camel_vee_folder_get_expression (search_folder);
if (g_strcmp0 (query, vf_query) == 0)
goto all_accounts_setup;
}
/* Disable the scope combo while search is in progress. */
gtk_widget_set_sensitive (GTK_WIDGET (combo_box), FALSE);
/* If we already have a search folder, reuse it. */
if (search_folder != NULL) {
if (priv->search_account_cancel != NULL) {
g_cancellable_cancel (priv->search_account_cancel);
g_object_unref (priv->search_account_cancel);
priv->search_account_cancel = NULL;
}
camel_vee_folder_set_expression (search_folder, query);
goto all_accounts_setup;
}
/* Create a new search folder. */
/* FIXME Complete lack of error checking here. */
service = camel_session_ref_service (
CAMEL_SESSION (session), E_MAIL_SESSION_VFOLDER_UID);
camel_service_connect_sync (service, NULL, NULL);
search_folder = (CamelVeeFolder *) camel_vee_folder_new (
CAMEL_STORE (service),
_("All Account Search"),
CAMEL_STORE_FOLDER_PRIVATE);
priv->search_account_all = search_folder;
g_object_unref (service);
camel_vee_folder_set_expression (search_folder, query);
all_accounts_setup:
list = em_folder_tree_model_list_stores (EM_FOLDER_TREE_MODEL (
gtk_tree_view_get_model (GTK_TREE_VIEW (folder_tree))));
g_list_foreach (list, (GFunc) g_object_ref, NULL);
priv->search_account_cancel = camel_operation_new ();
/* This takes ownership of the stores list. */
mail_shell_view_setup_search_results_folder (
CAMEL_FOLDER (search_folder), list,
priv->search_account_cancel);
mail_shell_view_show_search_results_folder (
E_MAIL_SHELL_VIEW (shell_view),
CAMEL_FOLDER (search_folder));
goto execute;
current_account:
/* Prepare search folder for current account only. */
/* If the search text is empty, cancel any
* account-wide searches still in progress. */
text = e_shell_searchbar_get_search_text (searchbar);
if (text == NULL || *text == '\0') {
CamelStore *selected_store = NULL;
gchar *selected_folder_name = NULL;
if (priv->search_account_current != NULL) {
g_object_unref (priv->search_account_current);
priv->search_account_current = NULL;
}
if (priv->search_account_cancel != NULL) {
g_cancellable_cancel (priv->search_account_cancel);
g_object_unref (priv->search_account_cancel);
priv->search_account_cancel = NULL;
}
/* Reset the message list to the current folder tree
* selection. This needs to happen synchronously to
* avoid search conflicts, so we can't just grab the
* folder URI and let the asynchronous callbacks run
* after we've already kicked off the search. */
em_folder_tree_get_selected (
folder_tree, &selected_store, &selected_folder_name);
if (selected_store != NULL && selected_folder_name != NULL) {
folder = camel_store_get_folder_sync (
selected_store, selected_folder_name,
CAMEL_STORE_FOLDER_INFO_FAST, NULL, NULL);
e_mail_reader_set_folder (reader, folder);
g_object_unref (folder);
}
g_clear_object (&selected_store);
g_free (selected_folder_name);
gtk_widget_set_sensitive (GTK_WIDGET (combo_box), TRUE);
goto execute;
}
search_folder = priv->search_account_current;
/* Skip the search if we already have the results. */
if (search_folder != NULL) {
const gchar *vf_query;
vf_query = camel_vee_folder_get_expression (search_folder);
if (g_strcmp0 (query, vf_query) == 0)
goto current_accout_setup;
}
/* Disable the scope combo while search is in progress. */
gtk_widget_set_sensitive (GTK_WIDGET (combo_box), FALSE);
/* If we already have a search folder, reuse it. */
if (search_folder != NULL) {
if (priv->search_account_cancel != NULL) {
g_cancellable_cancel (priv->search_account_cancel);
g_object_unref (priv->search_account_cancel);
priv->search_account_cancel = NULL;
}
camel_vee_folder_set_expression (search_folder, query);
goto current_accout_setup;
}
/* Create a new search folder. */
/* FIXME Complete lack of error checking here. */
service = camel_session_ref_service (
CAMEL_SESSION (session), E_MAIL_SESSION_VFOLDER_UID);
camel_service_connect_sync (service, NULL, NULL);
search_folder = (CamelVeeFolder *) camel_vee_folder_new (
CAMEL_STORE (service),
_("Account Search"),
CAMEL_STORE_FOLDER_PRIVATE);
priv->search_account_current = search_folder;
g_object_unref (service);
camel_vee_folder_set_expression (search_folder, query);
current_accout_setup:
if (folder != NULL && folder != CAMEL_FOLDER (search_folder)) {
store = camel_folder_get_parent_store (folder);
if (store != NULL)
g_object_ref (store);
} else {
store = NULL;
em_folder_tree_get_selected (folder_tree, &store, NULL);
}
list = NULL; /* list of CamelStore-s */
if (store != NULL)
list = g_list_append (NULL, store);
priv->search_account_cancel = camel_operation_new ();
/* This takes ownership of the stores list. */
mail_shell_view_setup_search_results_folder (
CAMEL_FOLDER (search_folder), list,
priv->search_account_cancel);
mail_shell_view_show_search_results_folder (
E_MAIL_SHELL_VIEW (shell_view),
CAMEL_FOLDER (search_folder));
execute:
/* Finally, execute the search. */
message_list_set_search (MESSAGE_LIST (message_list), query);
e_mail_view_set_search_strings (mail_view, search_strings);
g_slist_foreach (search_strings, (GFunc) g_free, NULL);
g_slist_free (search_strings);
g_free (query);
g_clear_object (&folder);
}
/* called with lock held */
static void
handle_block_uevent_for_drive (UDisksLinuxProvider *provider,
const gchar *action,
UDisksLinuxDevice *device)
{
UDisksLinuxDriveObject *object;
UDisksDaemon *daemon;
const gchar *sysfs_path;
gchar *vpd;
vpd = NULL;
daemon = udisks_provider_get_daemon (UDISKS_PROVIDER (provider));
sysfs_path = g_udev_device_get_sysfs_path (device->udev_device);
if (g_strcmp0 (action, "remove") == 0)
{
object = g_hash_table_lookup (provider->sysfs_path_to_drive, sysfs_path);
if (object != NULL)
{
GList *devices;
udisks_linux_drive_object_uevent (object, action, device);
g_warn_if_fail (g_hash_table_remove (provider->sysfs_path_to_drive, sysfs_path));
devices = udisks_linux_drive_object_get_devices (object);
if (devices == NULL)
{
const gchar *existing_vpd;
existing_vpd = g_object_get_data (G_OBJECT (object), "x-vpd");
g_dbus_object_manager_server_unexport (udisks_daemon_get_object_manager (daemon),
g_dbus_object_get_object_path (G_DBUS_OBJECT (object)));
g_warn_if_fail (g_hash_table_remove (provider->vpd_to_drive, existing_vpd));
}
g_list_foreach (devices, (GFunc) g_object_unref, NULL);
g_list_free (devices);
}
}
else
{
if (!udisks_linux_drive_object_should_include_device (provider->gudev_client, device, &vpd))
goto out;
if (vpd == NULL)
{
udisks_debug ("Ignoring block device %s with no serial or WWN",
g_udev_device_get_sysfs_path (device->udev_device));
goto out;
}
object = g_hash_table_lookup (provider->vpd_to_drive, vpd);
if (object != NULL)
{
if (g_hash_table_lookup (provider->sysfs_path_to_drive, sysfs_path) == NULL)
g_hash_table_insert (provider->sysfs_path_to_drive, g_strdup (sysfs_path), object);
udisks_linux_drive_object_uevent (object, action, device);
}
else
{
object = udisks_linux_drive_object_new (daemon, device);
if (object != NULL)
{
g_object_set_data_full (G_OBJECT (object), "x-vpd", g_strdup (vpd), g_free);
g_dbus_object_manager_server_export_uniquely (udisks_daemon_get_object_manager (daemon),
G_DBUS_OBJECT_SKELETON (object));
g_hash_table_insert (provider->vpd_to_drive, g_strdup (vpd), object);
g_hash_table_insert (provider->sysfs_path_to_drive, g_strdup (sysfs_path), object);
/* schedule initial housekeeping for the drive unless coldplugging */
if (!provider->coldplug)
{
g_io_scheduler_push_job (perform_initial_housekeeping_for_drive,
g_object_ref (object),
(GDestroyNotify) g_object_unref,
G_PRIORITY_DEFAULT,
NULL);
}
}
}
}
out:
g_free (vpd);
}
int cals_get_alarm_info(const int event_id, GList **alarm_list)
{
int ret = -1;
GList *result = NULL;
sqlite3_stmt *stmt = NULL;
cal_value * cvalue = NULL;
char query[CALS_SQL_MAX_LEN] = {0};
cal_alarm_info_t* alarm_info = NULL;
retv_if(NULL == alarm_list, CAL_ERR_ARG_NULL);
sprintf(query, "SELECT * FROM %s WHERE event_id=%d", CALS_TABLE_ALARM, event_id);
stmt = cals_query_prepare(query);
retvm_if(NULL == stmt, CAL_ERR_DB_FAILED, "cals_query_prepare() Failed");
ret = cals_stmt_step(stmt);
if (ret < CAL_SUCCESS) {
sqlite3_finalize(stmt);
ERR("cals_stmt_step() Failed(%d)", ret);
return ret;
}
while (CAL_TRUE == ret)
{
cvalue = calloc(1, sizeof(cal_value));
if (NULL == cvalue) {
sqlite3_finalize(stmt);
g_list_foreach(result, _cals_alarm_value_free, NULL);
g_list_free(result);
ERR("calloc() Failed(%d)", errno);
return CAL_ERR_OUT_OF_MEMORY;
}
cvalue->v_type = CAL_EVENT_ALARM;
cvalue->user_data = alarm_info = calloc(1, sizeof(cal_alarm_info_t));
if (NULL == alarm_info) {
sqlite3_finalize(stmt);
g_list_foreach(result, _cals_alarm_value_free, NULL);
g_list_free(result);
free(cvalue);
ERR("calloc() Failed(%d)", errno);
return CAL_ERR_OUT_OF_MEMORY;
}
alarm_info->event_id = sqlite3_column_int(stmt, 0);
alarm_info->alarm_time = sqlite3_column_int64(stmt, 1);
alarm_info->remind_tick = sqlite3_column_int(stmt, 2);
alarm_info->remind_tick_unit = sqlite3_column_int(stmt, 3);
alarm_info->alarm_tone = SAFE_STRDUP(sqlite3_column_text(stmt, 4));
alarm_info->alarm_description = SAFE_STRDUP(sqlite3_column_text(stmt, 5));
alarm_info->alarm_type = sqlite3_column_int(stmt, 6);
alarm_info->alarm_id = sqlite3_column_int(stmt, 7);
result = g_list_append(result, cvalue);
ret = cals_stmt_step(stmt);
}
sqlite3_finalize(stmt);
*alarm_list = result;
return CAL_SUCCESS;
}
/*
* delete selected rows from env variables page
*/
static void delete_selected_rows(void)
{
/* path to select after deleting finishes */
GtkTreeRowReference *reference_to_select = NULL;
/* empty row path */
GtkTreePath *empty_path = gtk_tree_row_reference_get_path(empty_row);
/* get selected rows */
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
GList *rows = gtk_tree_selection_get_selected_rows(selection, &model);
/* check whether only empty row was selected */
if (1 != gtk_tree_selection_count_selected_rows(selection) ||
gtk_tree_path_compare((GtkTreePath*)rows->data, empty_path))
{
GtkTreePath *path;
/* get references to the selected rows and find out what to
select after deletion */
GList *references = NULL;
GList *iter = rows;
while (iter)
{
path = (GtkTreePath*)iter->data;
if (!reference_to_select)
{
/* select upper sibling of the upper
selected row that has unselected upper sibling */
GtkTreePath *sibling = gtk_tree_path_copy(path);
if(gtk_tree_path_prev(sibling))
{
if (!gtk_tree_selection_path_is_selected(selection, sibling))
reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)), sibling);
}
else if (gtk_tree_path_next(sibling), gtk_tree_path_compare(path, sibling))
reference_to_select = gtk_tree_row_reference_new(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)), sibling);
}
if (gtk_tree_path_compare(path, empty_path))
references = g_list_append(references, gtk_tree_row_reference_new(model, path));
iter = iter->next;
}
/* if all (with or without empty row) was selected - set empty row
as a path to be selected after deleting */
if (!reference_to_select)
reference_to_select = gtk_tree_row_reference_copy (empty_row);
iter = references;
while (iter)
{
GtkTreeIter titer;
GtkTreeRowReference *reference = (GtkTreeRowReference*)iter->data;
path = gtk_tree_row_reference_get_path(reference);
gtk_tree_model_get_iter(model, &titer, path);
gtk_list_store_remove(store, &titer);
gtk_tree_path_free(path);
iter = iter->next;
}
/* set selection */
gtk_tree_selection_unselect_all(selection);
path = gtk_tree_row_reference_get_path(reference_to_select);
gtk_tree_selection_select_path(selection, path);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(tree), path, NULL, TRUE, 0.5, 0.5);
gtk_tree_path_free(path);
/* free references list */
g_list_foreach (references, (GFunc)gtk_tree_row_reference_free, NULL);
g_list_free (references);
}
/* free selection reference */
gtk_tree_row_reference_free(reference_to_select);
gtk_tree_path_free(empty_path);
/* free rows list */
g_list_foreach (rows, (GFunc)gtk_tree_path_free, NULL);
g_list_free (rows);
}
static void present_notification_dialogs (void)
{
g_list_foreach(input_list, show_dialog, NULL);
disable_blinking();
}
static gboolean
gst_adder_sink_event (GstCollectPads * pads, GstCollectData * pad,
GstEvent * event, gpointer user_data)
{
GstAdder *adder = GST_ADDER (user_data);
gboolean res = TRUE, discard = FALSE;
GST_DEBUG_OBJECT (pad->pad, "Got %s event on sink pad",
GST_EVENT_TYPE_NAME (event));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_CAPS:
{
GstCaps *caps;
gst_event_parse_caps (event, &caps);
res = gst_adder_setcaps (adder, pad->pad, caps);
gst_event_unref (event);
event = NULL;
break;
}
case GST_EVENT_FLUSH_START:
/* ensure that we will send a flush stop */
res = gst_collect_pads_event_default (pads, pad, event, discard);
event = NULL;
GST_COLLECT_PADS_STREAM_LOCK (adder->collect);
adder->flush_stop_pending = TRUE;
GST_COLLECT_PADS_STREAM_UNLOCK (adder->collect);
break;
case GST_EVENT_FLUSH_STOP:
/* we received a flush-stop. We will only forward it when
* flush_stop_pending is set, and we will unset it then.
*/
g_atomic_int_set (&adder->new_segment_pending, TRUE);
GST_COLLECT_PADS_STREAM_LOCK (adder->collect);
if (adder->flush_stop_pending) {
GST_DEBUG_OBJECT (pad->pad, "forwarding flush stop");
res = gst_collect_pads_event_default (pads, pad, event, discard);
adder->flush_stop_pending = FALSE;
event = NULL;
} else {
discard = TRUE;
GST_DEBUG_OBJECT (pad->pad, "eating flush stop");
}
GST_COLLECT_PADS_STREAM_UNLOCK (adder->collect);
/* Clear pending tags */
if (adder->pending_events) {
g_list_foreach (adder->pending_events, (GFunc) gst_event_unref, NULL);
g_list_free (adder->pending_events);
adder->pending_events = NULL;
}
break;
case GST_EVENT_TAG:
/* collect tags here so we can push them out when we collect data */
adder->pending_events = g_list_append (adder->pending_events, event);
event = NULL;
break;
case GST_EVENT_SEGMENT:{
const GstSegment *segment;
gst_event_parse_segment (event, &segment);
if (segment->rate != adder->segment.rate) {
GST_ERROR_OBJECT (pad->pad,
"Got segment event with wrong rate %lf, expected %lf",
segment->rate, adder->segment.rate);
res = FALSE;
gst_event_unref (event);
event = NULL;
}
discard = TRUE;
break;
}
default:
break;
}
if (G_LIKELY (event))
return gst_collect_pads_event_default (pads, pad, event, discard);
else
return res;
}
int main(int argc, char* argv[]) {
CefMainArgs main_args(argc, argv);
g_appStartupTime = time(NULL);
gtk_init(&argc, &argv);
CefRefPtr<ClientApp> app(new ClientApp);
// Execute the secondary process, if any.
int exit_code = CefExecuteProcess(main_args, app.get(), NULL);
if (exit_code >= 0)
return exit_code;
//Retrieve the current working directory
if (!getcwd(szWorkingDir, sizeof (szWorkingDir)))
return -1;
GtkWidget* window;
// Parse command line arguments.
AppInitCommandLine(argc, argv);
CefSettings settings;
// Populate the settings based on command line arguments.
AppGetSettings(settings, app);
settings.no_sandbox = TRUE;
// Check cache_path setting
if (CefString(&settings.cache_path).length() == 0) {
CefString(&settings.cache_path) = AppGetCachePath();
}
CefRefPtr<CefCommandLine> cmdLine = AppGetCommandLine();
if (cmdLine->HasSwitch(client::switches::kStartupPath)) {
szInitialUrl = cmdLine->GetSwitchValue(client::switches::kStartupPath);
} else {
szInitialUrl = AppGetRunningDirectory();
szInitialUrl.append("/dev/src/index.html");
if (!FileExists(szInitialUrl)) {
szInitialUrl = AppGetRunningDirectory();
szInitialUrl.append("/www/index.html");
if (!FileExists(szInitialUrl)) {
if (GetInitialUrl() < 0)
return 0;
}
}
}
// Initialize CEF.
CefInitialize(main_args, settings, app.get(), NULL);
// Set window icon
std::vector<std::string> icons(APPICONS, APPICONS + sizeof(APPICONS) / sizeof(APPICONS[0]) );
GList *list = NULL;
for (int i = 0; i < icons.size(); ++i) {
std::string path = icons[i];
GdkPixbuf *icon = gdk_pixbuf_new_from_file(path.c_str(), NULL);
if (!icon)
continue;
list = g_list_append(list, icon);
}
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
gtk_window_set_icon_list(GTK_WINDOW(window), list);
// Free icon list
g_list_foreach(list, (GFunc) g_object_unref, NULL);
g_list_free(list);
GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
GtkWidget* menuBar = gtk_menu_bar_new();
// GtkWidget* debug_menu = CreateMenu(menuBar, "Tests");
// AddMenuEntry(debug_menu, "Hello World Menu",
// G_CALLBACK(GetSourceActivated));
gtk_box_pack_start(GTK_BOX(vbox), menuBar, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(HandleQuit), NULL);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_widget_destroyed), &window);
add_handler_id = g_signal_connect(G_OBJECT(window), "add",
G_CALLBACK(HandleAdd), NULL);
// g_signal_connect(G_OBJECT(window), "destroy",
// G_CALLBACK(destroy), NULL);
// Create the handler.
g_handler = new ClientHandler();
g_handler->SetMainHwnd(vbox);
// Create the browser view.
CefWindowInfo window_info;
CefBrowserSettings browserSettings;
browserSettings.web_security = STATE_DISABLED;
window_info.SetAsChild(vbox);
CefBrowserHost::CreateBrowser(
window_info,
static_cast<CefRefPtr<CefClient> >(g_handler),
"file://"+szInitialUrl, browserSettings, NULL);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show_all(GTK_WIDGET(window));
// Install an signal handler so we clean up after ourselves.
signal(SIGINT, TerminationSignalHandler);
signal(SIGTERM, TerminationSignalHandler);
// Start the node server process
startNodeProcess();
CefRunMessageLoop();
CefShutdown();
return 0;
}
void g_list_free_full(GList *list,GDestroyNotify free_func)
{
g_list_foreach (list, (GFunc) free_func, NULL);
g_list_free (list);
}
gboolean
mm_base_modem_organize_ports (MMBaseModem *self,
GError **error)
{
GHashTableIter iter;
MMPort *candidate;
MMAtPortFlag flags;
MMAtSerialPort *backup_primary = NULL;
MMAtSerialPort *primary = NULL;
MMAtSerialPort *secondary = NULL;
MMAtSerialPort *backup_secondary = NULL;
MMQcdmSerialPort *qcdm = NULL;
MMAtSerialPort *gps_control = NULL;
MMGpsSerialPort *gps = NULL;
MMPort *data_primary = NULL;
GList *data = NULL;
#if defined WITH_QMI
MMPort *qmi_primary = NULL;
GList *qmi = NULL;
#endif
GList *l;
g_return_val_if_fail (MM_IS_BASE_MODEM (self), FALSE);
/* If ports have already been organized, just return success */
if (self->priv->primary)
return TRUE;
g_hash_table_iter_init (&iter, self->priv->ports);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &candidate)) {
switch (mm_port_get_port_type (candidate)) {
case MM_PORT_TYPE_AT:
g_assert (MM_IS_AT_SERIAL_PORT (candidate));
flags = mm_at_serial_port_get_flags (MM_AT_SERIAL_PORT (candidate));
if (flags & MM_AT_PORT_FLAG_PRIMARY) {
if (!primary)
primary = MM_AT_SERIAL_PORT (candidate);
else if (!backup_primary) {
/* Just in case the plugin gave us more than one primary
* and no secondaries, treat additional primary ports as
* secondary.
*/
backup_primary = MM_AT_SERIAL_PORT (candidate);
}
}
if (!data_primary && (flags & MM_AT_PORT_FLAG_PPP))
data_primary = candidate;
/* Explicitly flagged secondary ports trump NONE ports for secondary */
if (flags & MM_AT_PORT_FLAG_SECONDARY) {
if (!secondary || !(mm_at_serial_port_get_flags (secondary) & MM_AT_PORT_FLAG_SECONDARY))
secondary = MM_AT_SERIAL_PORT (candidate);
}
if (flags & MM_AT_PORT_FLAG_GPS_CONTROL) {
if (!gps_control)
gps_control = MM_AT_SERIAL_PORT (candidate);
}
/* Fallback secondary */
if (flags == MM_AT_PORT_FLAG_NONE) {
if (!secondary)
secondary = MM_AT_SERIAL_PORT (candidate);
else if (!backup_secondary)
backup_secondary = MM_AT_SERIAL_PORT (candidate);
}
break;
case MM_PORT_TYPE_QCDM:
g_assert (MM_IS_QCDM_SERIAL_PORT (candidate));
if (!qcdm)
qcdm = MM_QCDM_SERIAL_PORT (candidate);
break;
case MM_PORT_TYPE_NET:
/* Net device (if any) is the preferred data port */
if (!data_primary || MM_IS_AT_SERIAL_PORT (data_primary))
data_primary = candidate;
else
/* All non-primary net ports get added to the list of data ports */
data = g_list_append (data, candidate);
break;
case MM_PORT_TYPE_GPS:
g_assert (MM_IS_GPS_SERIAL_PORT (candidate));
if (!gps)
gps = MM_GPS_SERIAL_PORT (candidate);
break;
#if defined WITH_QMI
case MM_PORT_TYPE_QMI:
if (!qmi_primary)
qmi_primary = candidate;
else
/* All non-primary QMI ports get added to the list of QMI ports */
qmi = g_list_append (qmi, candidate);
break;
#endif
default:
/* Ignore port */
break;
}
}
/* Fall back to a secondary port if we didn't find a primary port */
if (!primary) {
#if defined WITH_QMI
/* On QMI-based modems we do allow not having a primary AT port */
if (!secondary && !qmi_primary) {
#else
if (!secondary) {
#endif
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Failed to find primary AT port");
return FALSE;
} else {
primary = secondary;
secondary = NULL;
}
}
/* If the plugin didn't give us any secondary ports, use any additional
* primary ports or backup secondary ports as secondary.
*/
if (!secondary)
secondary = backup_primary ? backup_primary : backup_secondary;
#if defined WITH_QMI
/* On QMI-based modems, we need to have at least a net port */
if (qmi_primary && !data_primary) {
g_set_error_literal (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Failed to find a net port in the QMI modem");
return FALSE;
}
#endif
/* Data port defaults to primary AT port */
if (!data_primary)
data_primary = MM_PORT (primary);
g_assert (data_primary);
/* Reset flags on all ports; clear data port first since it might also
* be the primary or secondary port.
*/
if (MM_IS_AT_SERIAL_PORT (data_primary))
mm_at_serial_port_set_flags (MM_AT_SERIAL_PORT (data_primary), MM_AT_PORT_FLAG_NONE);
mm_at_serial_port_set_flags (primary, MM_AT_PORT_FLAG_PRIMARY);
if (secondary)
mm_at_serial_port_set_flags (secondary, MM_AT_PORT_FLAG_SECONDARY);
if (MM_IS_AT_SERIAL_PORT (data_primary)) {
flags = mm_at_serial_port_get_flags (MM_AT_SERIAL_PORT (data_primary));
mm_at_serial_port_set_flags (MM_AT_SERIAL_PORT (data_primary), flags | MM_AT_PORT_FLAG_PPP);
}
log_port (self, MM_PORT (primary), "at (primary)");
log_port (self, MM_PORT (secondary), "at (secondary)");
log_port (self, MM_PORT (data_primary), "data (primary)");
for (l = data; l; l = g_list_next (l))
log_port (self, MM_PORT (l->data), "data (secondary)");
log_port (self, MM_PORT (qcdm), "qcdm");
log_port (self, MM_PORT (gps_control), "gps (control)");
log_port (self, MM_PORT (gps), "gps (nmea)");
#if defined WITH_QMI
log_port (self, MM_PORT (qmi_primary), "qmi (primary)");
for (l = qmi; l; l = g_list_next (l))
log_port (self, MM_PORT (l->data), "qmi (secondary)");
#endif
/* We keep new refs to the objects here */
self->priv->primary = g_object_ref (primary);
self->priv->secondary = (secondary ? g_object_ref (secondary) : NULL);
self->priv->qcdm = (qcdm ? g_object_ref (qcdm) : NULL);
self->priv->gps_control = (gps_control ? g_object_ref (gps_control) : NULL);
self->priv->gps = (gps ? g_object_ref (gps) : NULL);
/* Build the final list of data ports, primary port first */
self->priv->data = g_list_append (self->priv->data, g_object_ref (data_primary));
g_list_foreach (data, (GFunc)g_object_ref, NULL);
self->priv->data = g_list_concat (self->priv->data, data);
#if defined WITH_QMI
/* Build the final list of QMI ports, primary port first */
if (qmi_primary) {
self->priv->qmi = g_list_append (self->priv->qmi, g_object_ref (qmi_primary));
g_list_foreach (qmi, (GFunc)g_object_ref, NULL);
self->priv->qmi = g_list_concat (self->priv->qmi, qmi);
}
#endif
/* As soon as we get the ports organized, we initialize the modem */
mm_base_modem_initialize (self,
(GAsyncReadyCallback)initialize_ready,
NULL);
return TRUE;
}
/*****************************************************************************/
/* Authorization */
gboolean
mm_base_modem_authorize_finish (MMBaseModem *self,
GAsyncResult *res,
GError **error)
{
return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error);
}
static void
authorize_ready (MMAuthProvider *authp,
GAsyncResult *res,
GSimpleAsyncResult *simple)
{
GError *error = NULL;
if (!mm_auth_provider_authorize_finish (authp, res, &error))
g_simple_async_result_take_error (simple, error);
else
g_simple_async_result_set_op_res_gboolean (simple, TRUE);
g_simple_async_result_complete (simple);
g_object_unref (simple);
}
static void datasource_gps_add_setup_widgets ( GtkWidget *dialog, VikViewport *vvp, gpointer user_data )
{
gps_user_data_t *w = (gps_user_data_t *)user_data;
GtkTable *box, *data_type_box;
w->proto_l = gtk_label_new (_("GPS Protocol:"));
w->proto_b = vik_combo_box_text_new ();
g_list_foreach (a_babel_device_list, append_element, w->proto_b);
if ( last_active < 0 ) {
find_entry = -1;
wanted_entry = -1;
gchar *protocol = NULL;
if ( a_settings_get_string ( VIK_SETTINGS_GPS_PROTOCOL, &protocol ) ) {
// Use setting
if ( protocol )
g_list_foreach (a_babel_device_list, find_protocol, protocol);
}
else {
// Attempt to maintain default to Garmin devices (assumed most popular/numerous device)
g_list_foreach (a_babel_device_list, find_protocol, "garmin");
}
// If not found set it to the first entry, otherwise use the entry
last_active = ( wanted_entry < 0 ) ? 0 : wanted_entry;
}
gtk_combo_box_set_active (GTK_COMBO_BOX(w->proto_b), last_active);
g_object_ref(w->proto_b);
w->ser_l = gtk_label_new (_("Serial Port:"));
#if GTK_CHECK_VERSION (2, 24, 0)
w->ser_b = gtk_combo_box_text_new_with_entry ();
#else
w->ser_b = gtk_combo_box_entry_new_text ();
#endif
// Value from the settings is promoted to the top
gchar *gps_port = NULL;
if ( a_settings_get_string ( VIK_SETTINGS_GPS_PORT, &gps_port ) ) {
// Use setting if available
if ( gps_port ) {
#ifndef WINDOWS
if ( !strncmp (gps_port, "/dev/tty", 6) ) {
if (g_access (gps_port, R_OK) == 0) {
vik_combo_box_text_append (w->ser_b, gps_port);
}
}
else
#endif
vik_combo_box_text_append (w->ser_b, gps_port);
}
}
// Note avoid appending the port selected from the settings
#ifdef WINDOWS
if ( gps_port && strcmp (gps_port, "com1") )
vik_combo_box_text_append (w->ser_b, "com1");
#else
/* Here just try to see if the device is available which gets passed onto gpsbabel
List USB devices first as these will generally only be present if autogenerated by udev or similar
User is still able to set their own free text entry */
if ( gps_port && strcmp (gps_port, "/dev/ttyUSB0") )
if (g_access ("/dev/ttyUSB0", R_OK) == 0)
vik_combo_box_text_append (w->ser_b, "/dev/ttyUSB0");
if ( gps_port && strcmp (gps_port, "/dev/ttyUSB1") )
if (g_access ("/dev/ttyUSB1", R_OK) == 0)
vik_combo_box_text_append (w->ser_b, "/dev/ttyUSB1");
if ( gps_port && strcmp (gps_port, "/dev/ttyS0") )
if (g_access ("/dev/ttyS0", R_OK) == 0)
vik_combo_box_text_append (w->ser_b, "/dev/ttyS0");
if ( gps_port && strcmp (gps_port, "/dev/ttyS1") )
if (g_access ("/dev/ttyS1", R_OK) == 0)
vik_combo_box_text_append (w->ser_b, "/dev/ttyS1");
#endif
if ( gps_port && strcmp (gps_port, "usb:") )
vik_combo_box_text_append (w->ser_b, "usb:");
gtk_combo_box_set_active (GTK_COMBO_BOX(w->ser_b), 0);
g_object_ref(w->ser_b);
w->off_request_l = gtk_label_new (_("Turn Off After Transfer\n(Garmin/NAViLink Only)"));
w->off_request_b = GTK_CHECK_BUTTON ( gtk_check_button_new () );
gboolean power_off;
if ( ! a_settings_get_boolean ( VIK_SETTINGS_GPS_POWER_OFF, &power_off ) )
power_off = FALSE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->off_request_b), power_off);
w->get_tracks_l = gtk_label_new (_("Tracks:"));
w->get_tracks_b = GTK_CHECK_BUTTON ( gtk_check_button_new () );
gboolean get_tracks;
if ( ! a_settings_get_boolean ( VIK_SETTINGS_GPS_GET_TRACKS, &get_tracks ) )
get_tracks = TRUE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->get_tracks_b), get_tracks);
w->get_routes_l = gtk_label_new (_("Routes:"));
w->get_routes_b = GTK_CHECK_BUTTON ( gtk_check_button_new () );
gboolean get_routes;
if ( ! a_settings_get_boolean ( VIK_SETTINGS_GPS_GET_ROUTES, &get_routes ) )
get_routes = FALSE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->get_routes_b), get_routes);
w->get_waypoints_l = gtk_label_new (_("Waypoints:"));
w->get_waypoints_b = GTK_CHECK_BUTTON ( gtk_check_button_new () );
gboolean get_waypoints;
if ( ! a_settings_get_boolean ( VIK_SETTINGS_GPS_GET_WAYPOINTS, &get_waypoints ) )
get_waypoints = TRUE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w->get_waypoints_b), get_waypoints);
box = GTK_TABLE(gtk_table_new(2, 4, FALSE));
data_type_box = GTK_TABLE(gtk_table_new(4, 1, FALSE));
gtk_table_attach_defaults(box, GTK_WIDGET(w->proto_l), 0, 1, 0, 1);
gtk_table_attach_defaults(box, GTK_WIDGET(w->proto_b), 1, 2, 0, 1);
gtk_table_attach_defaults(box, GTK_WIDGET(w->ser_l), 0, 1, 1, 2);
gtk_table_attach_defaults(box, GTK_WIDGET(w->ser_b), 1, 2, 1, 2);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_tracks_l), 0, 1, 0, 1);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_tracks_b), 1, 2, 0, 1);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_routes_l), 2, 3, 0, 1);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_routes_b), 3, 4, 0, 1);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_waypoints_l), 4, 5, 0, 1);
gtk_table_attach_defaults(data_type_box, GTK_WIDGET(w->get_waypoints_b), 5, 6, 0, 1);
gtk_table_attach_defaults(box, GTK_WIDGET(data_type_box), 0, 2, 2, 3);
gtk_table_attach_defaults(box, GTK_WIDGET(w->off_request_l), 0, 1, 3, 4);
gtk_table_attach_defaults(box, GTK_WIDGET(w->off_request_b), 1, 3, 3, 4);
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), GTK_WIDGET(box), FALSE, FALSE, 5 );
gtk_widget_show_all ( dialog );
}
static void parse_str(StringInputVisitor *siv, Error **errp)
{
char *str = (char *) siv->string;
long long start, end;
Range *cur;
char *endptr;
if (siv->ranges) {
return;
}
do {
errno = 0;
start = strtoll(str, &endptr, 0);
if (errno == 0 && endptr > str) {
if (*endptr == '\0') {
cur = g_malloc0(sizeof(*cur));
cur->begin = start;
cur->end = start + 1;
siv->ranges = g_list_insert_sorted_merged(siv->ranges, cur,
range_compare);
cur = NULL;
str = NULL;
} else if (*endptr == '-') {
str = endptr + 1;
errno = 0;
end = strtoll(str, &endptr, 0);
if (errno == 0 && endptr > str && start <= end &&
(start > INT64_MAX - 65536 ||
end < start + 65536)) {
if (*endptr == '\0') {
cur = g_malloc0(sizeof(*cur));
cur->begin = start;
cur->end = end + 1;
siv->ranges =
g_list_insert_sorted_merged(siv->ranges,
cur,
range_compare);
cur = NULL;
str = NULL;
} else if (*endptr == ',') {
str = endptr + 1;
cur = g_malloc0(sizeof(*cur));
cur->begin = start;
cur->end = end + 1;
siv->ranges =
g_list_insert_sorted_merged(siv->ranges,
cur,
range_compare);
cur = NULL;
} else {
goto error;
}
} else {
goto error;
}
} else if (*endptr == ',') {
str = endptr + 1;
cur = g_malloc0(sizeof(*cur));
cur->begin = start;
cur->end = start + 1;
siv->ranges = g_list_insert_sorted_merged(siv->ranges,
cur,
range_compare);
cur = NULL;
} else {
goto error;
}
} else {
goto error;
}
} while (str);
return;
error:
g_list_foreach(siv->ranges, free_range, NULL);
g_list_free(siv->ranges);
siv->ranges = NULL;
}
void string_input_visitor_cleanup(StringInputVisitor *v)
{
g_list_foreach(v->ranges, free_range, NULL);
g_list_free(v->ranges);
g_free(v);
}
/**
* rb_list_destroy_free:
* @list: list to destroy
* @destroyer: function to call to free elements of @list
*
* Calls @destroyer for each element in @list, then frees @list.
*/
void
rb_list_destroy_free (GList *list, GDestroyNotify destroyer)
{
g_list_foreach (list, (GFunc)destroyer, NULL);
g_list_free (list);
}
/*!
\brief Creates the lookuptables configurator window (MS1 FW's only)
\param widget is unused
\param data is unused
\returns TRUE on success
*/
G_MODULE_EXPORT gboolean lookuptables_configurator(GtkWidget *widget, gpointer data)
{
static gboolean ltc_created = FALSE;
static GtkWidget * lookuptables_config_window = NULL;
GtkListStore *store = NULL;
GtkTreeStore *combostore = NULL;
GtkTreeIter iter;
GtkTreeIter per_iter;
GtkTreeIter sys_iter;
GtkCellRenderer *renderer = NULL;
GtkTreeViewColumn *column = NULL;
GtkWidget * vbox = NULL;
GtkWidget * tree = NULL;
GtkWidget * frame = NULL;
GtkWidget * label = NULL;
ListElement *element = NULL;
ConfigFile *cfgfile = NULL;
GArray *classes = NULL;
GList *p_list = NULL;
GList *s_list = NULL;
gchar * tmpbuf = NULL;
gchar ** vector = NULL;
gchar ** tmpvector = NULL;
Firmware_Details *firmware = NULL;
ENTER();
firmware = (Firmware_Details *)DATA_GET(global_data,"firmware");
if ((ltc_created) && (ltc_visible))
{
EXIT();
return TRUE;
}
if ((ltc_created) && (!ltc_visible))
{
gtk_widget_show_all(lookuptables_config_window);
EXIT();
return TRUE;
}
else /* i.e. NOT created, build it */
{
lookuptables_config_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(lookuptables_config_window),_("MegaTunix LookupTables"));
gtk_window_set_default_size(GTK_WINDOW(lookuptables_config_window),300,200);
vbox = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(lookuptables_config_window),vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox),5);
g_signal_connect(G_OBJECT(lookuptables_config_window),"delete_event", G_CALLBACK(lookuptables_configurator_hide),NULL);
ltc_created = TRUE;
ltc_visible = TRUE;
frame = gtk_frame_new("MegaTunix LookupTables");
gtk_box_pack_start (GTK_BOX(vbox),frame,TRUE,TRUE,5);
vbox = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(frame),vbox);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label),_(" Click on the <i>LookupTable Filename</i> and press <b><u> Enter </u></b> to change "));
gtk_box_pack_start(GTK_BOX(vbox),label,TRUE,TRUE,5);
store = gtk_list_store_new(N_COLS, /* total cols */
G_TYPE_STRING, /* int name */
G_TYPE_STRING, /* filename combo*/
G_TYPE_BOOLEAN,/* View/Edit */
G_TYPE_BOOLEAN); /* change */
combostore = gtk_tree_store_new(1,G_TYPE_STRING);/* lookuptable filename */
gtk_tree_store_append(combostore,&per_iter,NULL);
gtk_tree_store_append(combostore,&sys_iter,NULL);
gtk_tree_store_set(combostore,&per_iter,
0,"Personal", -1);
gtk_tree_store_set(combostore,&sys_iter,
0,"System", -1);
vector = get_files((const gchar *)DATA_GET(global_data,"project_name"),LOOKUPTABLES_DATA_DIR,"inc",&classes);
for (guint i=0;i<g_strv_length(vector);i++)
{
tmpvector = g_strsplit(vector[i],PSEP,-1);
if (g_array_index(classes,FileClass,i) == PERSONAL)
{
element = (ListElement *)g_new0(ListElement, 1);
element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]);
p_list = g_list_append(p_list,element);
}
if (g_array_index(classes,FileClass,i) == SYSTEM)
{
element = (ListElement *)g_new0(ListElement, 1);
element->name = g_strdup(tmpvector[g_strv_length(tmpvector)-1]);
s_list = g_list_append(s_list,element);
}
g_strfreev(tmpvector);
}
g_strfreev(vector);
g_array_free(classes,TRUE);
p_list = g_list_sort(p_list,list_sort);
s_list = g_list_sort(s_list,list_sort);
for (guint i=0;i<g_list_length(p_list);i++)
{
gtk_tree_store_append(combostore,&iter,&per_iter);
element = (ListElement *)g_list_nth_data(p_list,i);
gtk_tree_store_set(combostore,&iter,
0,element->name,
-1);
}
for (guint i=0;i<g_list_length(s_list);i++)
{
gtk_tree_store_append(combostore,&iter,&sys_iter);
element = (ListElement *)g_list_nth_data(s_list,i);
gtk_tree_store_set(combostore,&iter,
0,element->name,
-1);
}
g_list_foreach(p_list,free_element,NULL);
g_list_foreach(s_list,free_element,NULL);
g_list_free(p_list);
g_list_free(s_list);
cfgfile = cfg_open_file(firmware->profile_filename);
if (!cfgfile)
{
EXIT();
return FALSE;
}
cfg_read_string(cfgfile,"lookuptables","tables",&tmpbuf);
vector = g_strsplit(tmpbuf,",",-1);
g_free(tmpbuf);
for (guint i=0;i<g_strv_length(vector);i++)
{
cfg_read_string(cfgfile,"lookuptables",vector[i],&tmpbuf);
gtk_list_store_append(store,&iter);
gtk_list_store_set(store,&iter,
INTERNAL_NAME_COL,vector[i],
FILENAME_COL,tmpbuf,
VIEW_EDIT_COL,FALSE,
-1);
g_free(tmpbuf);
}
g_strfreev(vector);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree),TRUE);
gtk_box_pack_start(GTK_BOX(vbox),tree,TRUE,TRUE,0);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Internal Table Name",renderer,"text",INTERNAL_NAME_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
renderer = gtk_cell_renderer_combo_new();
g_object_set(G_OBJECT(renderer),"has-entry",FALSE,"editable",TRUE,"model",combostore,"text-column",0,"style",PANGO_STYLE_ITALIC,NULL);
g_signal_connect(G_OBJECT(renderer),"changed", G_CALLBACK(lookuptable_changed),store);
// g_signal_connect(G_OBJECT(renderer),"editing-started", G_CALLBACK(editing_started),store);
column = gtk_tree_view_column_new_with_attributes("LookupTable Filename",renderer,"text",FILENAME_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
/* renderer = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes("View/Edit",renderer,"active",VIEW_EDIT_COL,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree),column);
*/
gtk_window_set_transient_for(GTK_WINDOW(lookuptables_config_window),GTK_WINDOW(lookup_widget("main_window")));
gtk_widget_show_all (lookuptables_config_window);
gtk_tree_view_columns_autosize( GTK_TREE_VIEW(tree));
gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(tree),GTK_TREE_VIEW_GRID_LINES_BOTH);
// g_signal_connect(G_OBJECT(tree),"row-activated", G_CALLBACK(row_activated),NULL);
}
EXIT();
return TRUE;
}
static void
free_list (GList *list)
{
g_list_foreach (list, (GFunc) g_object_unref, NULL);
g_list_free (list);
}
static void
path_list_free( GList *path_list )
{
g_list_foreach( path_list, ( GFunc ) gtk_tree_row_reference_free, NULL );
g_list_free( path_list );
}
static void historize(PurpleConversation *c)
{
PurpleAccount *account = purple_conversation_get_account(c);
const char *name = purple_conversation_get_name(c);
GList *logs = NULL;
const char *alias = name;
guint flags;
char *history;
PidginConversation *gtkconv;
#if 0
/* FIXME: WebView has no options */
GtkIMHtmlOptions options = GTK_IMHTML_NO_COLOURS;
#endif
char *header;
#if 0
/* FIXME: WebView has no protocol setting */
char *protocol;
#endif
char *escaped_alias;
const char *header_date;
gtkconv = PIDGIN_CONVERSATION(c);
g_return_if_fail(gtkconv != NULL);
/* An IM which is the first active conversation. */
g_return_if_fail(gtkconv->convs != NULL);
if (PURPLE_IS_IM_CONVERSATION(c) && !gtkconv->convs->next)
{
GSList *buddies;
GSList *cur;
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_ims"))
return;
/* Find buddies for this conversation. */
buddies = purple_blist_find_buddies(account, name);
/* If we found at least one buddy, save the first buddy's alias. */
if (buddies != NULL)
alias = purple_buddy_get_contact_alias(PURPLE_BUDDY(buddies->data));
for (cur = buddies; cur != NULL; cur = cur->next)
{
PurpleBlistNode *node = cur->data;
PurpleBlistNode *prev = purple_blist_node_get_sibling_prev(node);
PurpleBlistNode *next = purple_blist_node_get_sibling_next(node);
if ((node != NULL) && ((prev != NULL) || (next != NULL)))
{
PurpleBlistNode *node2;
PurpleBlistNode *parent = purple_blist_node_get_parent(node);
PurpleBlistNode *child = purple_blist_node_get_first_child(parent);
alias = purple_buddy_get_contact_alias(PURPLE_BUDDY(node));
/* We've found a buddy that matches this conversation. It's part of a
* PurpleContact with more than one PurpleBuddy. Loop through the PurpleBuddies
* in the contact and get all the logs. */
for (node2 = child ; node2 != NULL ; node2 = purple_blist_node_get_sibling_next(node2))
{
logs = g_list_concat(purple_log_get_logs(PURPLE_LOG_IM,
purple_buddy_get_name(PURPLE_BUDDY(node2)),
purple_buddy_get_account(PURPLE_BUDDY(node2))),
logs);
}
break;
}
}
g_slist_free(buddies);
if (logs == NULL)
logs = purple_log_get_logs(PURPLE_LOG_IM, name, account);
else
logs = g_list_sort(logs, purple_log_compare);
}
else if (PURPLE_IS_CHAT_CONVERSATION(c))
{
/* If we're not logging, don't show anything.
* Otherwise, we might show a very old log. */
if (!purple_prefs_get_bool("/purple/logging/log_chats"))
return;
logs = purple_log_get_logs(PURPLE_LOG_CHAT, name, account);
}
if (logs == NULL)
return;
history = purple_log_read((PurpleLog*)logs->data, &flags);
gtkconv = PIDGIN_CONVERSATION(c);
#if 0
/* FIXME: WebView has no options */
if (flags & PURPLE_LOG_READ_NO_NEWLINE)
options |= GTK_IMHTML_NO_NEWLINE;
#endif
#if 0
/* FIXME: WebView has no protocol setting */
protocol = g_strdup(gtk_imhtml_get_protocol_name(GTK_IMHTML(gtkconv->imhtml)));
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml),
purple_account_get_protocol_name(((PurpleLog*)logs->data)->account));
#endif
#if 0
/* TODO WebKit: Do this properly... */
if (!pidgin_webview_is_empty(PIDGIN_WEBVIEW(gtkconv->webview)))
pidgin_webview_append_html(PIDGIN_WEBVIEW(gtkconv->webview), "<BR>");
#endif
escaped_alias = g_markup_escape_text(alias, -1);
if (((PurpleLog *)logs->data)->tm)
header_date = purple_date_format_full(((PurpleLog *)logs->data)->tm);
else
header_date = purple_date_format_full(localtime(&((PurpleLog *)logs->data)->time));
header = g_strdup_printf(_("<b>Conversation with %s on %s:</b><br>"), escaped_alias, header_date);
pidgin_webview_append_html(PIDGIN_WEBVIEW(gtkconv->webview), header);
g_free(header);
g_free(escaped_alias);
g_strchomp(history);
pidgin_webview_append_html(PIDGIN_WEBVIEW(gtkconv->webview), history);
g_free(history);
pidgin_webview_append_html(PIDGIN_WEBVIEW(gtkconv->webview), "<hr>");
#if 0
/* FIXME: WebView has no protocol setting */
gtk_imhtml_set_protocol_name(GTK_IMHTML(gtkconv->imhtml), protocol);
g_free(protocol);
#endif
g_object_ref(G_OBJECT(gtkconv->webview));
g_idle_add(_scroll_webview_to_end, gtkconv->webview);
g_list_foreach(logs, (GFunc)purple_log_free, NULL);
g_list_free(logs);
}
static void
glade_eprop_accel_show_dialog (GladeEditorProperty *eprop)
{
GladeEPropAccel *eprop_accel = GLADE_EPROP_ACCEL (eprop);
GtkWidget *dialog, *parent, *vbox, *sw, *tree_view;
GValue value = { 0, };
GList *accelerators = NULL;
gint res;
parent = gtk_widget_get_toplevel (GTK_WIDGET (eprop));
dialog = gtk_dialog_new_with_buttons (_("Choose accelerator keys..."),
GTK_WINDOW (parent),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLEAR, GLADE_RESPONSE_CLEAR,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show (vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_box_pack_start (GTK_BOX
(gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox,
TRUE, TRUE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (sw);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_widget_set_size_request (sw, 400, 200);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
tree_view = glade_eprop_accel_view (eprop);
glade_eprop_accel_populate_view (eprop, GTK_TREE_VIEW (tree_view));
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
gtk_widget_show (tree_view);
gtk_container_add (GTK_CONTAINER (sw), tree_view);
/* Run the dialog */
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_OK)
{
gtk_tree_model_foreach
(gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)),
(GtkTreeModelForeachFunc)
glade_eprop_accel_accum_accelerators, &accelerators);
g_value_init (&value, GLADE_TYPE_ACCEL_GLIST);
g_value_take_boxed (&value, accelerators);
glade_editor_property_commit (eprop, &value);
g_value_unset (&value);
}
else if (res == GLADE_RESPONSE_CLEAR)
{
g_value_init (&value, GLADE_TYPE_ACCEL_GLIST);
g_value_set_boxed (&value, NULL);
glade_editor_property_commit (eprop, &value);
g_value_unset (&value);
}
/* Clean up ...
*/
gtk_widget_destroy (dialog);
g_object_unref (G_OBJECT (eprop_accel->model));
eprop_accel->model = NULL;
if (eprop_accel->parent_iters)
{
g_list_foreach (eprop_accel->parent_iters, (GFunc) iter_tab_free, NULL);
g_list_free (eprop_accel->parent_iters);
eprop_accel->parent_iters = NULL;
}
}
static void
thunar_vfs_volume_hal_update (ThunarVfsVolumeHal *volume_hal,
LibHalContext *context,
LibHalVolume *hv,
LibHalDrive *hd)
{
gchar *desired_mount_point;
gchar *mount_root;
gchar *basename;
gchar *filename;
_thunar_vfs_return_if_fail (THUNAR_VFS_IS_VOLUME_HAL (volume_hal));
_thunar_vfs_return_if_fail (hd != NULL);
/* reset the volume status */
volume_hal->status = 0;
/* determine the new device file */
g_free (volume_hal->device_file);
volume_hal->device_file = g_strdup ((hv != NULL) ? libhal_volume_get_device_file (hv) : libhal_drive_get_device_file (hd));
/* compute a usable display name for the volume/drive */
g_free (volume_hal->device_label);
volume_hal->device_label = (hv == NULL)
? exo_hal_drive_compute_display_name (context, hd)
: exo_hal_volume_compute_display_name (context, hv, hd);
if (G_UNLIKELY (volume_hal->device_label == NULL))
{
/* use the basename of the device file as label */
volume_hal->device_label = g_path_get_basename (volume_hal->device_file);
}
/* compute a usable list of icon names for the volume/drive */
g_list_foreach (volume_hal->icon_list, (GFunc) g_free, NULL);
g_list_free (volume_hal->icon_list);
volume_hal->icon_list = (hv == NULL)
? exo_hal_drive_compute_icon_list (context, hd)
: exo_hal_volume_compute_icon_list (context, hv, hd);
/* release the previous mount point (if any) */
if (G_LIKELY (volume_hal->mount_point != NULL))
{
thunar_vfs_path_unref (volume_hal->mount_point);
volume_hal->mount_point = NULL;
}
/* determine the type of the volume */
switch (libhal_drive_get_type (hd))
{
case LIBHAL_DRIVE_TYPE_CDROM:
/* check if we have a pure audio CD without any data track */
if (libhal_volume_disc_has_audio (hv) && !libhal_volume_disc_has_data (hv))
{
/* special treatment for pure audio CDs */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_AUDIO_CD;
}
else
{
/* check which kind of CD-ROM/DVD we have */
switch (libhal_volume_get_disc_type (hv))
{
case LIBHAL_VOLUME_DISC_TYPE_CDROM:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_CDROM;
break;
case LIBHAL_VOLUME_DISC_TYPE_CDR:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_CDR;
break;
case LIBHAL_VOLUME_DISC_TYPE_CDRW:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_CDRW;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDROM:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDROM;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDRAM:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDRAM;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDR:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDR;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDRW:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDRW;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDPLUSR:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDPLUSR;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDPLUSRW:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDPLUSRW;
break;
default:
/* unsupported disc type */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_UNKNOWN;
break;
}
}
break;
case LIBHAL_DRIVE_TYPE_FLOPPY:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_FLOPPY;
break;
case LIBHAL_DRIVE_TYPE_PORTABLE_AUDIO_PLAYER:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_AUDIO_PLAYER;
break;
case LIBHAL_DRIVE_TYPE_SMART_MEDIA:
case LIBHAL_DRIVE_TYPE_SD_MMC:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_MEMORY_CARD;
break;
default:
/* check if the drive is connected to the USB bus */
if (libhal_drive_get_bus (hd) == LIBHAL_DRIVE_BUS_USB)
{
/* we consider the drive to be an USB stick */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_USBSTICK;
}
else if (libhal_drive_uses_removable_media (hd)
|| libhal_drive_is_hotpluggable (hd))
{
/* fallback to generic removable disk */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_REMOVABLE_DISK;
}
else
{
/* fallback to harddisk drive */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_HARDDISK;
}
break;
}
/* either we have a volume, which means we have media, or
* a drive, which means non-pollable then, so it's present
*/
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_PRESENT;
/* figure out if the volume is mountable */
if(hv != NULL && libhal_volume_get_fsusage (hv) == LIBHAL_VOLUME_USAGE_MOUNTABLE_FILESYSTEM)
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_MOUNTABLE;
/* check if the drive requires eject */
volume_hal->requires_eject = libhal_drive_requires_eject (hd);
/* check if the volume is currently mounted */
if (hv != NULL && libhal_volume_is_mounted (hv))
{
/* try to determine the new mount point */
volume_hal->mount_point = thunar_vfs_path_new (libhal_volume_get_mount_point (hv), NULL);
/* we only mark the volume as mounted if we have a valid mount point */
if (G_LIKELY (volume_hal->mount_point != NULL))
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_MOUNTED | THUNAR_VFS_VOLUME_STATUS_PRESENT;
}
else
{
/* we don't trust HAL, so let's see what the kernel says about the volume */
volume_hal->mount_point = thunar_vfs_volume_hal_find_active_mount_point (volume_hal);
/* we must have been mounted successfully if we have a mount point */
if (G_LIKELY (volume_hal->mount_point != NULL))
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_MOUNTED | THUNAR_VFS_VOLUME_STATUS_PRESENT;
}
/* check if we have to figure out the mount point ourself */
if (G_UNLIKELY (volume_hal->mount_point == NULL))
{
/* ask HAL for the default mount root (falling back to /media otherwise) */
mount_root = libhal_device_get_property_string (context, "/org/freedesktop/Hal/devices/computer", "storage.policy.default.mount_root", NULL);
if (G_UNLIKELY (mount_root == NULL || !g_path_is_absolute (mount_root)))
{
/* fallback to /media (seems to be sane) */
g_free (mount_root);
mount_root = g_strdup ("/media");
}
/* lets see, maybe /etc/fstab knows where to mount */
volume_hal->mount_point = thunar_vfs_volume_hal_find_fstab_mount_point (volume_hal);
/* if we still don't have a mount point, ask HAL */
if (G_UNLIKELY (volume_hal->mount_point == NULL))
{
/* determine the desired mount point and prepend the mount root */
desired_mount_point = libhal_device_get_property_string (context, volume_hal->udi, "volume.policy.desired_mount_point", NULL);
if (G_LIKELY (desired_mount_point != NULL && *desired_mount_point != '\0'))
{
filename = g_build_filename (mount_root, desired_mount_point, NULL);
volume_hal->mount_point = thunar_vfs_path_new (filename, NULL);
g_free (filename);
}
libhal_free_string (desired_mount_point);
}
/* ok, last fallback, just use <mount-root>/<device> */
if (G_UNLIKELY (volume_hal->mount_point == NULL))
{
/* <mount-root>/<device> looks like a good idea */
basename = g_path_get_basename (volume_hal->device_file);
filename = g_build_filename (mount_root, basename, NULL);
volume_hal->mount_point = thunar_vfs_path_new (filename, NULL);
g_free (filename);
g_free (basename);
}
/* release the mount root */
g_free (mount_root);
}
/* if we get here, we must have a valid mount point */
g_assert (volume_hal->mount_point != NULL);
/* emit the "changed" signal */
thunar_vfs_volume_changed (THUNAR_VFS_VOLUME (volume_hal));
}
/*! \todo Finish function documentation!!!
* \brief
* \par Function Description
*
*/
void s_stretch_destroy_all (GList *list)
{
g_list_foreach (list, (GFunc)g_free, NULL);
g_list_free (list);
}
WTextItem FontSupport::measureText(const WFont& font, const WString& text,
double maxWidth, bool wordWrap)
{
PANGO_LOCK;
/*
* Note: accurate measuring on a bitmap requires that the transformation
* is applied, because hinting may push chars to boundaries e.g. when
* rotated (or scaled too?)
*/
std::string utf8 = text.toUTF8();
const char *s = utf8.c_str();
if (wordWrap) {
int utflen = g_utf8_strlen(s, -1);
PangoLogAttr *attrs = new PangoLogAttr[utflen + 1];
PangoLanguage *language = pango_language_from_string("en-US");
pango_get_log_attrs(s, utf8.length(), -1, language, attrs, utflen + 1);
double w = 0, nextW = -1;
int current = 0;
int measured = 0;
int end = 0;
bool maxWidthReached = false;
for (int i = 0; i < utflen + 1; ++i) {
if (i == utflen || attrs[i].is_line_break) {
int cend = g_utf8_offset_to_pointer(s, end) - s;
WTextItem ti
= measureText(font, WString::fromUTF8(utf8.substr(measured,
cend - measured)),
-1, false);
if (isEpsilonMore(w + ti.width(), maxWidth)) {
nextW = ti.width();
maxWidthReached = true;
break;
} else {
measured = cend;
current = g_utf8_offset_to_pointer(s, i) - s;
w += ti.width();
if (i == utflen) {
w += measureText(font, WString::fromUTF8(utf8.substr(measured)),
-1, false).width();
measured = utf8.length();
}
}
}
if (!attrs[i].is_white)
end = i + 1;
}
delete[] attrs;
if (maxWidthReached) {
return WTextItem(WString::fromUTF8(utf8.substr(0, current)), w, nextW);
} else {
/*
* For some reason, the sum of the individual widths is a bit less
* (for longer stretches of text), so we re-measure it !
*/
w = measureText(font, WString::fromUTF8(utf8.substr(0, measured)),
-1, false).width();
return WTextItem(text, w);
}
} else {
std::vector<PangoGlyphString *> glyphs;
int width;
GList *items = layoutText(font, utf8, glyphs, width);
double w = pangoUnitsToDouble(width);
for (unsigned i = 0; i < glyphs.size(); ++i)
pango_glyph_string_free(glyphs[i]);
g_list_foreach(items, (GFunc) pango_item_free, 0);
g_list_free(items);
return WTextItem(text, w);
}
}
void
cdda_remove_from_playlist(cdda_drive_t * drive) {
g_list_foreach(playlists, cdda_remove_from_playlist_foreach, drive);
}
static void
databases_browse_xxx (DMAPShare * share,
SoupServer * server,
SoupMessage * msg,
const char *path,
GHashTable * query, SoupClientContext * context)
{
/* ABRO database browse
* MSTT status
* MUTY update type
* MTCO specified total count
* MRCO returned count
* ABGN genre listing
* MLIT listing item
* ...
*/
DMAPDb *db;
const gchar *rest_of_path;
GNode *abro, *node;
gchar *filter;
GSList *filter_def;
GHashTable *filtered;
guint num_genre;
const gchar *browse_category;
GHashTable *category_items;
DMAPContentCode category_cc;
GList *values;
rest_of_path = strchr (path + 1, '/');
browse_category = rest_of_path + 10;
category_items = g_hash_table_new (g_str_hash, g_str_equal);
filter = g_hash_table_lookup (query, "filter");
filter_def = _dmap_share_build_filter (filter);
g_object_get (share, "db", &db, NULL);
filtered = dmap_db_apply_filter (db, filter_def);
if (g_ascii_strcasecmp (browse_category, "genres") == 0) {
g_hash_table_foreach (filtered, (GHFunc) genre_tabulator,
category_items);
category_cc = DMAP_CC_ABGN;
} else if (g_ascii_strcasecmp (browse_category, "artists") == 0) {
g_hash_table_foreach (filtered, (GHFunc) artist_tabulator,
category_items);
category_cc = DMAP_CC_ABAR;
} else if (g_ascii_strcasecmp (browse_category, "albums") == 0) {
g_hash_table_foreach (filtered, (GHFunc) album_tabulator,
category_items);
category_cc = DMAP_CC_ABAL;
} else {
g_warning ("Unsupported browse category: %s",
browse_category);
goto _bad_category;
}
abro = dmap_structure_add (NULL, DMAP_CC_ABRO);
dmap_structure_add (abro, DMAP_CC_MSTT, (gint32) DMAP_STATUS_OK);
dmap_structure_add (abro, DMAP_CC_MUTY, 0);
num_genre = g_hash_table_size (category_items);
dmap_structure_add (abro, DMAP_CC_MTCO, (gint32) num_genre);
dmap_structure_add (abro, DMAP_CC_MRCO, (gint32) num_genre);
node = dmap_structure_add (abro, category_cc);
values = g_hash_table_get_keys (category_items);
if (values && g_hash_table_lookup (query, "include-sort-headers")) {
g_debug ("Sorting...");
values = g_list_sort (values,
(GCompareFunc) g_ascii_strcasecmp);
}
g_list_foreach (values, add_to_category_listing, node);
g_list_free (values);
_dmap_share_message_set_from_dmap_structure (share, msg, abro);
dmap_structure_destroy (abro);
_bad_category:
dmap_share_free_filter (filter_def);
/* Free's hash table but not data (points into real DB): */
g_hash_table_destroy (filtered);
g_hash_table_destroy (category_items);
}
void dusb_vtl_pkt_purge(void)
{
g_list_foreach(vtl_pkt_list, (GFunc)dusb_vtl_pkt_del, NULL);
g_list_free(vtl_pkt_list);
vtl_pkt_list = NULL;
}
bool CNewFilesDlg::Execute(void)
{
int mode, res;
char msg[256];
bool recursive, name_check, object_check, filter_check, background;
const char *name, *object, *filter, *dirpath;
// Default state
mode = g_Project->GetInt("NewFiles", "Mode", 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_AllBtn), !mode);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_FilesBtn), mode);
// Go to last folder
gchar *aux = g_Project->GetStr("AddFiles", "Folder", NULL);
if (!aux || !g_file_test(aux, G_FILE_TEST_IS_DIR))
aux = CConfig::GetStr("AddFiles", "Folder", NULL);
if (aux)
gtk_entry_set_text(GTK_ENTRY(m_DirEdit), aux);
else
gtk_entry_set_text(GTK_ENTRY(m_DirEdit), "");
g_free(aux);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_SubDirs),
g_Project->GetBool("NewFiles", "SubDirs"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_NameCheck),
g_Project->GetBool("NewFiles", "Name"));
aux = g_Project->GetStr("NewFiles", "NameText", "");
if (aux)
gtk_entry_set_text(GTK_ENTRY(m_NameEdit), aux);
else
gtk_entry_set_text(GTK_ENTRY(m_NameEdit), "");
g_free(aux);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_FilterCheck),
g_Project->GetBool("NewFiles", "Filter"));
aux = g_Project->GetStr("NewFiles", "FilterText", "");
if (aux)
gtk_entry_set_text(GTK_ENTRY(m_FilterEdit), aux);
else
gtk_entry_set_text(GTK_ENTRY(m_FilterEdit), "");
g_free(aux);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_ObjectCheck),
g_Project->GetBool("NewFiles", "Object"));
aux = g_Project->GetStr("NewFiles", "ObjectText", "");
if (aux)
gtk_entry_set_text(GTK_ENTRY(m_ObjectEdit), aux);
else
gtk_entry_set_text(GTK_ENTRY(m_ObjectEdit), "");
g_free(aux);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_BgCheck),
g_Project->GetBool("NewFiles", "Background"));
m_InFiles = m_OutFiles = 0;
UpdateControls();
if (gtk_dialog_run(GTK_DIALOG(m_pDlg))!=GTK_RESPONSE_ACCEPT)
return false;
gtk_widget_hide(m_pDlg);
// Save parameters
mode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_FilesBtn));
g_Project->SetInt("NewFiles", "Mode", (!mode ? 0 : 1));
dirpath = gtk_entry_get_text(GTK_ENTRY(m_DirEdit));
g_Project->SetStr("AddFiles", "Folder", dirpath);
CConfig::SetStr("AddFiles", "Folder", dirpath);
recursive = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_SubDirs))!=0;
g_Project->SetBool("NewFiles", "SubDirs", recursive);
name_check = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_NameCheck))!=0;
g_Project->SetBool("NewFiles", "Name", name_check);
name = gtk_entry_get_text(GTK_ENTRY(m_NameEdit));
g_Project->SetStr("NewFiles", "NameText", name);
filter_check = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_FilterCheck))!=0;
g_Project->SetBool("NewFiles", "Filter", filter_check);
filter = gtk_entry_get_text(GTK_ENTRY(m_FilterEdit));
g_Project->SetStr("NewFiles", "FilterText", filter);
object_check = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_ObjectCheck))!=0;
g_Project->SetBool("NewFiles", "Object", object_check);
object = gtk_entry_get_text(GTK_ENTRY(m_ObjectEdit));
g_Project->SetStr("NewFiles", "ObjectText", object);
background = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_BgCheck))!=0;
g_Project->SetBool("NewFiles", "Background", background);
// Background process?
if (background) {
CNewFilesBox *pBox = g_MainWnd->NewFilesBox();
if (pBox)
pBox->Show(true);
return true;
}
// Make list of files
m_FrameList = NULL;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_AllBtn))) {
// Make list of unprocessed frames
gtk_tree_model_foreach(g_Project->FileList(), foreach_all_files, &m_FrameList);
if (!m_FrameList) {
ShowError(m_pParent, "There are no unprocessed frames in the project.");
return false;
}
CProgressDlg pDlg(m_pParent, "Processing frames");
pDlg.SetMinMax(0, g_list_length(m_FrameList));
res = pDlg.Execute(FramesProc, this);
if (res!=0) {
char *msg = cmpack_formaterror(res);
ShowError(m_pParent, msg, true);
cmpack_free(msg);
} else if (m_OutFiles==0) {
ShowError(m_pParent, "No frame was successfully processed.", true);
} else if (m_OutFiles!=m_InFiles) {
sprintf(msg, "%d frame(s) was successfully processed, %d frame(s) failed.", m_OutFiles, m_InFiles-m_OutFiles);
ShowWarning(m_pParent, msg, true);
} else {
sprintf(msg, "All %d frame(s) was successfully processed.", m_OutFiles);
ShowInformation(m_pParent, msg, true);
}
g_list_foreach(m_FrameList, (GFunc)gtk_tree_row_reference_free, NULL);
g_list_free(m_FrameList);
m_FrameList = NULL;
} else {
// Add new files to the project
CProgressDlg pDlg(m_pParent, "Processing files");
res = pDlg.Execute(FilesProc, this);
if (res!=0) {
char *msg = cmpack_formaterror(res);
ShowError(m_pParent, msg, true);
cmpack_free(msg);
} else if (m_InFiles==0) {
ShowError(m_pParent, "There are no unprocessed files that fit the specified conditions.");
} else if (m_OutFiles==0) {
ShowError(m_pParent, "No file was successfully processed.", true);
} else if (m_OutFiles!=m_InFiles) {
sprintf(msg, "%d new file(s) were successfully processed, %d file(s) failed.", m_OutFiles, m_InFiles-m_OutFiles);
ShowWarning(m_pParent, msg, true);
} else {
sprintf(msg, "All %d file(s) were successfully processed.", m_OutFiles);
ShowInformation(m_pParent, msg, true);
}
}
g_Project->Save();
return true;
}
void
contact_list_editor_drag_data_received_cb (GtkWidget *widget,
GdkDragContext *context,
gint x, gint y,
GtkSelectionData *selection_data,
guint info,
guint time)
{
EContactListEditor *editor;
EContactListModel *model;
gchar *target_type;
gboolean changed = FALSE;
gboolean handled = FALSE;
GList *list, *iter;
editor = contact_list_editor_extract (widget);
model = E_CONTACT_LIST_MODEL (editor->priv->model);
target_type = gdk_atom_name (selection_data->target);
if (strcmp (target_type, VCARD_TYPE) != 0)
goto exit;
list = eab_contact_list_from_string ((gchar *) selection_data->data);
if (list != NULL)
handled = TRUE;
for (iter = list; iter != NULL; iter = iter->next) {
EContact *contact = iter->data;
const gchar *email;
if (e_contact_get (contact, E_CONTACT_IS_LIST))
continue;
email = e_contact_get (contact, E_CONTACT_EMAIL_1);
if (email == NULL) {
g_warning (
"Contact with no email-ids listed "
"can't be added to a Contact-List");
continue;
}
if (!contact_list_editor_contact_exists (model, email)) {
/* Hard-wired for default e-mail */
e_contact_list_model_add_contact (model, contact, 0);
changed = TRUE;
}
}
g_list_foreach (list, (GFunc) g_object_unref, NULL);
g_list_free (list);
contact_list_editor_scroll_to_end (editor);
if (changed) {
editor->priv->changed = TRUE;
contact_list_editor_update (editor);
}
exit:
gtk_drag_finish (context, handled, FALSE, time);
}
static gpointer vfs_file_task_thread ( VFSFileTask* task )
{
GList * l;
struct stat file_stat;
dev_t dest_dev = 0;
GFunc funcs[] = {( GFunc ) vfs_file_task_move,
( GFunc ) vfs_file_task_copy,
( GFunc ) vfs_file_task_move, /* trash */
( GFunc ) vfs_file_task_delete,
( GFunc ) vfs_file_task_link,
( GFunc ) vfs_file_task_chown_chmod};
if ( task->type < VFS_FILE_TASK_MOVE
|| task->type >= VFS_FILE_TASK_LAST )
goto _exit_thread;
task->state = VFS_FILE_TASK_RUNNING;
task->current_file = ( char* ) task->src_paths->data;
task->total_size = 0;
if( task->type == VFS_FILE_TASK_TRASH )
{
task->dest_dir = g_build_filename( vfs_get_trash_dir(), "files", NULL );
/* Create the trash dir if it doesn't exist */
if( ! g_file_test( task->dest_dir, G_FILE_TEST_EXISTS ) )
g_mkdir_with_parents( task->dest_dir, 0700 );
}
call_progress_callback( task );
/* Calculate total size of all files */
if ( task->recursive )
{
for ( l = task->src_paths; l; l = l->next )
{
if( task->dest_dir && g_str_has_prefix( task->dest_dir, (char*)l->data ) )
{
/* FIXME: This has serious problems */
/* Check if source file is contained in destination dir */
/* The src file is already in dest dir */
if( lstat( (char*)l->data, &file_stat ) == 0
&& S_ISDIR(file_stat.st_mode) )
{
/* It's a dir */
if ( task->state_cb )
{
char* err;
char* disp_src;
char* disp_dest;
disp_src = g_filename_display_name( (char*)l->data );
disp_dest = g_filename_display_name( task->dest_dir );
err = g_strdup_printf( _("Destination directory \"%1$s\" is contained in source \"%2$s\""), disp_dest, disp_src );
if ( task->state_cb( task, VFS_FILE_TASK_ERROR,
err, task->state_cb_data ) )
task->state = VFS_FILE_TASK_RUNNING;
else
task->state = VFS_FILE_TASK_ABORTED;
g_free( disp_src );
g_free( disp_dest );
g_free( err );
}
else
task->state = VFS_FILE_TASK_ABORTED;
if ( should_abort( task ) )
goto _exit_thread;
}
}
get_total_size_of_dir( task, ( char* ) l->data, &task->total_size );
}
}
else
{
if ( task->type != VFS_FILE_TASK_CHMOD_CHOWN )
{
if ( task->dest_dir &&
lstat( task->dest_dir, &file_stat ) < 0 )
{
task->error = errno;
call_state_callback( task, VFS_FILE_TASK_ERROR );
if ( should_abort( task ) )
goto _exit_thread;
}
dest_dev = file_stat.st_dev;
}
for ( l = task->src_paths; l; l = l->next )
{
if ( lstat( ( char* ) l->data, &file_stat ) == -1 )
{
task->error = errno;
call_state_callback( task, VFS_FILE_TASK_ERROR );
if ( should_abort( task ) )
goto _exit_thread;
}
if ( S_ISLNK( file_stat.st_mode ) ) /* Don't do deep copy for symlinks */
task->recursive = FALSE;
else if ( task->type == VFS_FILE_TASK_MOVE || task->type == VFS_FILE_TASK_TRASH )
task->recursive = ( file_stat.st_dev != dest_dev );
if ( task->recursive )
{
get_total_size_of_dir( task, ( char* ) l->data,
&task->total_size );
}
else
{
task->total_size += file_stat.st_size;
}
}
}
g_list_foreach( task->src_paths,
funcs[ task->type ],
task );
_exit_thread:
if ( task->state_cb )
call_state_callback( task, VFS_FILE_TASK_FINISH );
else
{
/* FIXME: Will this cause any problem? */
task->thread = NULL;
vfs_file_task_free( task );
}
return NULL;
}
static void load_events_foreach_workflow(const char *name, workflow_t *workflow, gpointer user_data)
{
g_list_foreach(wf_get_event_list(workflow), (GFunc)load_single_event_config_foreach, NULL);
}
