void save_file_as_cb( GtkWidget *widget, AnypaperWindow *window )
{
GtkWidget *dialog, *dialog_error;
GtkFileFilter *filterImages, *filterAll;
dialog = gtk_file_chooser_dialog_new ("Save as...",
GTK_WINDOW(window->priv->window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
filterImages = gtk_file_filter_new ();
gtk_file_filter_set_name (GTK_FILE_FILTER(filterImages),"JPEG images");
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(filterImages), "image/jpeg/*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filterImages);
filterAll = gtk_file_filter_new ();
gtk_file_filter_set_name (GTK_FILE_FILTER(filterAll),"All files");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filterAll), "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filterAll);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), FALSE);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), g_path_get_dirname (gtk_entry_get_text (GTK_ENTRY (window->priv->file_entry))));
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), "Untitled image.png");
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
char *filename, *down_filename;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
down_filename = g_ascii_strdown (filename, -1);
if ((g_str_has_suffix (down_filename, ".jpg")) || (g_str_has_suffix (down_filename, ".jpeg"))) gdk_pixbuf_save (window->image->image, filename, "jpeg", NULL, "quality", "100", NULL);
else if(g_str_has_suffix (down_filename, ".png")) gdk_pixbuf_save (window->image->image, filename, "png", NULL, NULL);
else
{
dialog_error = gtk_message_dialog_new (GTK_WINDOW (window->priv->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Invalid format");
gtk_window_set_title (GTK_WINDOW (dialog_error), "Error");
g_signal_connect_swapped (dialog_error, "response", G_CALLBACK (gtk_widget_destroy), dialog_error);
gtk_widget_show(dialog_error);
}
g_free (filename);
g_free (down_filename);
}
gtk_widget_destroy (dialog);
}
void wxFileDialog::SetFilterIndex(int filterIndex)
{
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
gpointer filter;
GtkFileChooser *chooser = GTK_FILE_CHOOSER(m_widget);
GSList *filters = gtk_file_chooser_list_filters(chooser);
filter = g_slist_nth_data(filters, filterIndex);
if (filter != NULL)
{
gtk_file_chooser_set_filter(chooser, GTK_FILE_FILTER(filter));
}
else
{
wxFAIL_MSG( wxT("wxFileDialog::SetFilterIndex - bad filter index") );
}
g_slist_free(filters);
}
else
#endif
wxGenericFileDialog::SetFilterIndex( filterIndex );
}
GtkFileFilter* GtkToolkitFileChooser::GetFilterById(int id)
{
GSList* list = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(m_dialog));
GtkFileFilter* filter = GTK_FILE_FILTER(g_slist_nth_data(list, id));
g_slist_free(list);
return filter;
}
void wxGtkFileChooser::SetWildcard( const wxString& wildCard )
{
m_wildcards.Empty();
// parse filters
wxArrayString wildDescriptions, wildFilters;
if ( !wxParseCommonDialogsFilter( wildCard, wildDescriptions, wildFilters ) )
{
wxFAIL_MSG( wxT( "wxGtkFileChooser::SetWildcard - bad wildcard string" ) );
}
else
{
// Parsing went fine. Set m_wildCard to be returned by wxGtkFileChooserBase::GetWildcard
GtkFileChooser* chooser = m_widget;
// empty current filter list:
GSList* ifilters = gtk_file_chooser_list_filters( chooser );
GSList* filters = ifilters;
m_ignoreNextFilterEvent = true;
wxON_BLOCK_EXIT_SET(m_ignoreNextFilterEvent, false);
while ( ifilters )
{
gtk_file_chooser_remove_filter( chooser, GTK_FILE_FILTER( ifilters->data ) );
ifilters = ifilters->next;
}
g_slist_free( filters );
if (!wildCard.empty())
{
// add parsed to GtkChooser
for ( size_t n = 0; n < wildFilters.GetCount(); ++n )
{
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_set_name( filter, wxGTK_CONV_SYS( wildDescriptions[n] ) );
wxStringTokenizer exttok( wildFilters[n], wxT( ";" ) );
int n1 = 1;
while ( exttok.HasMoreTokens() )
{
wxString token = exttok.GetNextToken();
gtk_file_filter_add_pattern( filter, wxGTK_CONV_SYS( token ) );
if (n1 == 1)
m_wildcards.Add( token ); // Only add first pattern to list, used later when saving
n1++;
}
gtk_file_chooser_add_filter( chooser, filter );
}
// Reset the filter index
SetFilterIndex( 0 );
}
}
}
static void reset_filter (GtkWidget *widget, GParamSpec *spec, gpointer user_data)
{
if (!gtk_file_chooser_get_filter (GTK_FILE_CHOOSER (widget))) {
g_signal_handlers_block_by_func (widget, reset_filter, user_data);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (widget), GTK_FILE_FILTER (user_data));
g_signal_handlers_unblock_by_func (widget, reset_filter, user_data);
}
}
void GtkFileChooserDialog_::remove_filter(Php::Parameters ¶meters)
{
Php::Value object_filter = parameters[0];
GtkFileFilter_ *phpgtk_filter = (GtkFileFilter_ *)object_filter.implementation();
GtkFileFilter *filter = GTK_FILE_FILTER(phpgtk_filter->get_instance());
gtk_file_chooser_remove_filter (GTK_FILE_CHOOSER(instance), filter);
}
void
assign_etf_fc_filters(GtkFileChooser *fc) {
GtkFileFilter *filter_1, *filter_2;
/* all files filter */
filter_1 = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter_1, "*");
gtk_file_filter_set_name(GTK_FILE_FILTER(filter_1), _("All Files"));
gtk_file_chooser_add_filter(fc, filter_1);
/* music store files filter */
filter_2 = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter_2, "*.[lL][uU][aA]");
gtk_file_filter_set_name(GTK_FILE_FILTER(filter_2), _("Lua Extension Files (*.lua)"));
gtk_file_chooser_add_filter(fc, filter_2);
gtk_file_chooser_set_filter(fc, filter_2);
}
void
assign_store_fc_filters(GtkFileChooser *fc) {
GtkFileFilter *filter_1, *filter_2;
/* all files filter */
filter_1 = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter_1, "*");
gtk_file_filter_set_name(GTK_FILE_FILTER(filter_1), _("All Files"));
gtk_file_chooser_add_filter(fc, filter_1);
/* music store files filter */
filter_2 = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter_2, "*.[xX][mM][lL]");
gtk_file_filter_set_name(GTK_FILE_FILTER(filter_2), _("Music Store Files (*.xml)"));
gtk_file_chooser_add_filter(fc, filter_2);
gtk_file_chooser_set_filter(fc, filter_2);
}
void ui_save_file_cb(GtkWidget* widget, gpointer data)
{
GtkWidget *filedialog;
GtkFileFilter *filefilter;
filedialog = gtk_file_chooser_dialog_new("Save...",
GTK_WINDOW(ui_window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE,
GTK_RESPONSE_ACCEPT,
NULL);
GList *handlers = io_get_save_handlers();
GList *iter;
for(iter = g_list_first(handlers); iter; iter = g_list_next(iter)) {
plugin_save_handler_t *handler = (plugin_save_handler_t *) iter->data;
filefilter = gtk_file_filter_new();
gtk_file_filter_set_name(GTK_FILE_FILTER(filefilter),
handler->desc);
int i;
for(i=0; i<handler->nfilters; i++) {
gtk_file_filter_add_pattern(GTK_FILE_FILTER(filefilter),
(char*) handler->filters[i]);
}
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filedialog),
filefilter);
g_object_set_data(G_OBJECT(filefilter), "handler", (gpointer) handler);
}
g_list_free(handlers);
if(gtk_dialog_run(GTK_DIALOG(filedialog)) == GTK_RESPONSE_ACCEPT) {
GtkWidget* filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(filedialog));
plugin_save_handler_t *handler = g_object_get_data(G_OBJECT(filter), "handler");
gchar *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filedialog));
io_save_image(path, handler);
}
gtk_widget_destroy(GTK_WIDGET(filedialog));
}
bool FileDialogImpl::run()
{
//Init the dialog
GtkWidget* fileDialog = gtk_file_chooser_dialog_new(
m_title.c_str(),
nullptr,
m_action == FileDialog::Open ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE,
_("_Cancel"),
GTK_RESPONSE_CANCEL,
m_action == FileDialog::Open ? _("_Open") : _("Save"),
GTK_RESPONSE_ACCEPT,
nullptr
);
//Init the filters
for(auto it = m_filters.cbegin(); it != m_filters.cend(); ++it)
{
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, it->name.c_str());
for(auto it2 = it->patterns.cbegin(); it2 != it->patterns.cend(); ++it2)
gtk_file_filter_add_pattern(filter, (*it2).c_str());
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fileDialog), filter);
}
//Set the default filter
GSList* filtersList = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(fileDialog));
if(m_selectedFilter < g_slist_length(filtersList))
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(fileDialog), GTK_FILE_FILTER(g_slist_nth_data(filtersList, m_selectedFilter)));
g_slist_free(filtersList);
gtk_window_set_keep_above(GTK_WINDOW(fileDialog), TRUE);
//Run it
gint result = gtk_dialog_run(GTK_DIALOG(fileDialog));
if(result == GTK_RESPONSE_ACCEPT)
{
char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fileDialog));
m_selectedFileName = std::string(filename);
g_free(filename);
}
gtk_window_close(GTK_WINDOW(fileDialog));
gtk_widget_destroy(fileDialog);
while (gtk_events_pending())
gtk_main_iteration_do(false);
return result == GTK_RESPONSE_ACCEPT;
}
void wxFileDialog::SetWildcard(const wxString& wildCard)
{
#ifdef __WXGTK24__
if (!gtk_check_version(2,4,0))
{
// parse filters
wxArrayString wildDescriptions, wildFilters;
if (!wxParseCommonDialogsFilter(wildCard, wildDescriptions, wildFilters))
{
wxFAIL_MSG( wxT("wxFileDialog::SetWildCard - bad wildcard string") );
}
else
{
// Parsing went fine. Set m_wildCard to be returned by wxFileDialogBase::GetWildcard
m_wildCard = wildCard;
GtkFileChooser* chooser = GTK_FILE_CHOOSER(m_widget);
// empty current filter list:
GSList* ifilters = gtk_file_chooser_list_filters(chooser);
GSList* filters = ifilters;
while (ifilters)
{
gtk_file_chooser_remove_filter(chooser,GTK_FILE_FILTER(ifilters->data));
ifilters = ifilters->next;
}
g_slist_free(filters);
// add parsed to GtkChooser
for (size_t n = 0; n < wildFilters.GetCount(); ++n)
{
GtkFileFilter* filter = gtk_file_filter_new();
gtk_file_filter_set_name(filter, wxGTK_CONV(wildDescriptions[n]));
wxStringTokenizer exttok(wildFilters[n], wxT(";"));
while (exttok.HasMoreTokens())
{
wxString token = exttok.GetNextToken();
gtk_file_filter_add_pattern(filter, wxGTK_CONV(token));
}
gtk_file_chooser_add_filter(chooser, filter);
}
// Reset the filter index
SetFilterIndex(0);
}
}
else
#endif
wxGenericFileDialog::SetWildcard( wildCard );
}
static void
import_adapt_extension_callback(GtkWidget *widget)
{
int index = gtk_combo_box_get_active (GTK_COMBO_BOX(widget));
GtkFileFilter *former = NULL;
GSList *list, *elem;
list = gtk_file_chooser_list_filters (GTK_FILE_CHOOSER (opendlg));
for (elem = list; elem != NULL; elem = g_slist_next (elem))
if (strcmp (_("Supported Formats"), gtk_file_filter_get_name (GTK_FILE_FILTER(elem->data))) == 0)
former = GTK_FILE_FILTER(elem->data);
g_slist_free (list);
if (former) {
/* replace the previous filter */
GtkFileFilter *filter = build_gtk_file_filter_from_index (index);
gtk_file_chooser_remove_filter (GTK_FILE_CHOOSER (opendlg), former);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (opendlg), filter);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (opendlg), filter);
}
}
void
assign_playlist_fc_filters(GtkFileChooser *fc) {
gchar *file_filters[] = {
_("Aqualung playlist (*.xml)"), "*.[xX][mM][lL]",
_("MP3 Playlist (*.m3u)"), "*.[mM]3[uU]",
_("Multimedia Playlist (*.pls)"), "*.[pP][lL][sS]",
};
gint i, len;
GtkFileFilter *filter_1, *filter_2, *filter_3;
len = sizeof(file_filters)/sizeof(gchar*)/2;
/* all files filter */
filter_1 = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter_1, "*");
gtk_file_filter_set_name(GTK_FILE_FILTER(filter_1), _("All Files"));
gtk_file_chooser_add_filter(fc, filter_1);
/* all playlist files filter */
filter_2 = gtk_file_filter_new();
for (i = 0; i < len; i++) {
gtk_file_filter_add_pattern(filter_2, file_filters[2*i+1]);
}
gtk_file_filter_set_name(GTK_FILE_FILTER(filter_2), _("All Playlist Files"));
gtk_file_chooser_add_filter(fc, filter_2);
gtk_file_chooser_set_filter(fc, filter_2);
/* single extensions */
for (i = 0; i < len; i++) {
filter_3 = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter_3, file_filters[2*i+1]);
gtk_file_filter_set_name(GTK_FILE_FILTER(filter_3), file_filters[2*i]);
gtk_file_chooser_add_filter(fc, filter_3);
}
}
int
clip_GTK_FILEFILTERGETNEEDED(ClipMachine * cm)
{
C_object *cfilter = _fetch_co_arg(cm);
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
_clip_retni(cm, (int)gtk_file_filter_get_needed(GTK_FILE_FILTER(cfilter->object)));
return 0;
err:
return 1;
}
int
clip_GTK_FILEFILTERADDPIXBUFFORMATS(ClipMachine * cm)
{
C_object *cfilter = _fetch_co_arg(cm);
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
gtk_file_filter_add_pixbuf_formats(GTK_FILE_FILTER(cfilter->object));
return 0;
err:
return 1;
}
static void import_clicked (GtkWidget *w,gpointer user_data)
{
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("select style"),
GTK_WINDOW (win),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
(char *)NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), FALSE);
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(filechooser),g_get_home_dir());
GtkFileFilter *filter;
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_pattern(filter, "*.dtstyle");
gtk_file_filter_set_name(filter, _("darktable style files"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_pattern(filter, "*");
gtk_file_filter_set_name(filter, _("all files"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT )
{
char *filename;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (filechooser));
dt_styles_import_from_file(filename);
//
dt_lib_styles_t *d = (dt_lib_styles_t *)user_data;
_gui_styles_update_view(d);
//
g_free (filename);
}
gtk_widget_destroy (filechooser);
}
int
clip_GTK_FILEFILTERADDMIMETYPE(ClipMachine * cm)
{
C_object *cfilter = _fetch_co_arg(cm);
gchar *type = _clip_parc(cm, 2);
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
CHECKARG(2, CHARACTER_t);
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(cfilter->object), type);
return 0;
err:
return 1;
}
int
clip_GTK_FILEFILTERADDPATTERN(ClipMachine * cm)
{
C_object *cfilter = _fetch_co_arg(cm);
gchar *pattern = _clip_parc(cm, 2);
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
CHECKARG(2, CHARACTER_t);
gtk_file_filter_add_pattern(GTK_FILE_FILTER(cfilter->object), pattern);
return 0;
err:
return 1;
}
int
clip_GTK_FILECHOOSERSETFILTER(ClipMachine * ClipMachineMemory)
{
C_object *cchooser = _fetch_co_arg(ClipMachineMemory);
C_object *cfilter = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(cchooser->object), GTK_FILE_FILTER(cfilter->object));
return 0;
err:
return 1;
}
int
clip_GTK_FILEFILTERFILTER(ClipMachine * cm)
{
C_object *cfilter = _fetch_co_arg(cm);
ClipVar *cv = _clip_spar(cm, 2);
GtkFileFilterInfo info;
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
CHECKARG(2, MAP_t);
_map_to_file_filter_info(cm, cv, &info);
_clip_retl(cm, gtk_file_filter_filter(GTK_FILE_FILTER(cfilter->object), &info));
return 0;
err:
return 1;
}
void
gnac_ui_on_filter_changed(GtkWidget *file_chooser,
GtkComboBox *combo)
{
GtkTreeIter iter;
if (!gtk_combo_box_get_active_iter(combo, &iter)) return;
GtkTreeModel *model = gtk_combo_box_get_model(combo);
g_return_if_fail(model);
gpointer filter;
gtk_tree_model_get(model, &iter, 0, &filter, -1);
if (GTK_IS_FILE_FILTER(filter)) {
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(file_chooser),
GTK_FILE_FILTER(filter));
}
}
int
clip_GTK_FILEFILTERGETNAME(ClipMachine * cm)
{
C_object *cfilter = _fetch_co_arg(cm);
gchar *name ;
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
name = (gchar *)gtk_file_filter_get_name(GTK_FILE_FILTER(cfilter->object));
LOCALE_FROM_UTF(name);
_clip_retc(cm, name);
FREE_TEXT(name);
return 0;
err:
return 1;
}
int
clip_GTK_FILEFILTERSETNAME(ClipMachine * cm)
{
C_object *cfilter = _fetch_co_arg(cm);
gchar *name = _clip_parc(cm, 2);
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
CHECKARG(2, CHARACTER_t);
LOCALE_TO_UTF(name);
gtk_file_filter_set_name(GTK_FILE_FILTER(cfilter->object), name);
FREE_TEXT(name);
return 0;
err:
return 1;
}
void wxGtkFileChooser::SetFilterIndex( int filterIndex )
{
gpointer filter;
GtkFileChooser *chooser = m_widget;
GSList *filters = gtk_file_chooser_list_filters( chooser );
filter = g_slist_nth_data( filters, filterIndex );
if ( filter != NULL )
{
gtk_file_chooser_set_filter( chooser, GTK_FILE_FILTER( filter ) );
}
else
{
wxFAIL_MSG( wxT( "wxGtkFileChooser::SetFilterIndex - bad filter index" ) );
}
g_slist_free( filters );
}
int
clip_GTK_FILEFILTERADDCUSTOM(ClipMachine * cm)
{
C_object *cfilter = _fetch_co_arg(cm);
GtkFileFilterFlags flags = _clip_parni(cm, 2);
ClipVar *func = _clip_spar(cm, 3);
C_var *c = 0;
CHECKCOBJ(cfilter, GTK_IS_FILE_FILTER(cfilter->object));
CHECKARG(2, NUMERIC_t); CHECKOPT2(3, PCODE_t, CCODE_t);
c->cm = cm; c->co = cfilter; _clip_mclone(cm, &c->cfunc, func);
gtk_file_filter_add_custom(GTK_FILE_FILTER(cfilter->object),
flags, (GtkFileFilterFunc)_file_filter_func, c, NULL);
return 0;
err:
return 1;
}
int
clip_GTK_FILECHOOSERLISTFILTERS(ClipMachine * ClipMachineMemory)
{
C_object *cchooser = _fetch_co_arg(ClipMachineMemory);
GSList *list;
ClipVar *cv = RETPTR(ClipMachineMemory);
long l;
CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
list = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(cchooser->object));
l = g_slist_length(list);
_clip_array(ClipMachineMemory, cv, 1, &l);
for (l = 0; list; list = g_slist_next(list), l++)
{
GtkFileFilter *filter;
C_object *cfilter;
filter = GTK_FILE_FILTER(list->data);
cfilter = _list_get_cobject(ClipMachineMemory, filter);
if (!cfilter)
cfilter = _register_object(ClipMachineMemory, filter, GTK_TYPE_FILE_FILTER, NULL, NULL);
if (cfilter)
_clip_aset(ClipMachineMemory, cv, &cfilter->obj, 1, &l);
}
g_slist_free(list);
return 0;
err:
return 1;
}
void
pragha_application_open_files (PraghaApplication *pragha)
{
PraghaPreferences *preferences;
GtkWidget *window, *hbox, *vbox, *chooser, *bbox, *toggle, *close_button, *add_button;
gpointer storage;
gint i = 0;
GtkFileFilter *media_filter, *playlist_filter, *all_filter;
const gchar *last_folder = NULL;
/* Create a file chooser dialog */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title(GTK_WINDOW(window), (_("Select a file to play")));
gtk_window_set_default_size(GTK_WINDOW(window), 700, 450);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_widget_set_name (GTK_WIDGET(window), "GtkFileChooserDialog");
gtk_container_set_border_width(GTK_CONTAINER(window), 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_name (GTK_WIDGET(vbox), "dialog-vbox1");
gtk_container_add(GTK_CONTAINER(window), vbox);
chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
/* Set various properties */
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(chooser), TRUE);
preferences = pragha_application_get_preferences (pragha);
last_folder = pragha_preferences_get_last_folder (preferences);
if (string_is_not_empty(last_folder))
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(chooser), last_folder);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);
toggle = gtk_check_button_new_with_label(_("Add files recursively"));
if(pragha_preferences_get_add_recursively (preferences))
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), TRUE);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(bbox), 4);
close_button = gtk_button_new_with_mnemonic (_("_Cancel"));
add_button = gtk_button_new_with_mnemonic (_("_Add"));
gtk_container_add(GTK_CONTAINER(bbox), close_button);
gtk_container_add(GTK_CONTAINER(bbox), add_button);
gtk_box_pack_start(GTK_BOX(hbox), toggle, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), bbox, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), chooser, TRUE, TRUE, 0);
/* Create file filters */
media_filter = gtk_file_filter_new();
gtk_file_filter_set_name(GTK_FILE_FILTER(media_filter), _("Supported media"));
while (mime_wav[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_wav[i++]);
i = 0;
while (mime_mpeg[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_mpeg[i++]);
i = 0;
while (mime_flac[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_flac[i++]);
i = 0;
while (mime_ogg[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_ogg[i++]);
i = 0;
while (mime_asf[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_asf[i++]);
i = 0;
while (mime_mp4[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_mp4[i++]);
i = 0;
while (mime_ape[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_ape[i++]);
i = 0;
while (mime_tracker[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_tracker[i++]);
#ifdef HAVE_PLPARSER
i = 0;
while (mime_playlist[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_playlist[i++]);
i = 0;
while (mime_dual[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(media_filter),
mime_dual[i++]);
#else
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.m3u");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.M3U");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.pls");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.PLS");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.xspf");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.XSPF");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.wax");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(media_filter), "*.WAX");
#endif
playlist_filter = gtk_file_filter_new();
#ifdef HAVE_PLPARSER
i = 0;
while (mime_playlist[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(playlist_filter),
mime_playlist[i++]);
i = 0;
while (mime_dual[i])
gtk_file_filter_add_mime_type(GTK_FILE_FILTER(playlist_filter),
mime_dual[i++]);
#else
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.m3u");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.M3U");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.pls");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.PLS");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.xspf");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.XSPF");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.wax");
gtk_file_filter_add_pattern(GTK_FILE_FILTER(playlist_filter), "*.WAX");
#endif
gtk_file_filter_set_name(GTK_FILE_FILTER(playlist_filter), _("Playlists"));
all_filter = gtk_file_filter_new ();
gtk_file_filter_set_name (GTK_FILE_FILTER(all_filter), _("All files"));
gtk_file_filter_add_pattern (GTK_FILE_FILTER(all_filter), "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(chooser),
GTK_FILE_FILTER(media_filter));
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(chooser),
GTK_FILE_FILTER(playlist_filter));
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER(chooser),
GTK_FILE_FILTER(all_filter));
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(chooser),
GTK_FILE_FILTER(media_filter));
storage = g_object_new(G_TYPE_OBJECT, NULL);
g_object_set_data(storage, "window", window);
g_object_set_data(storage, "chooser", chooser);
g_object_set_data(storage, "toggle-button", toggle);
g_object_set_data(storage, "pragha", pragha);
g_signal_connect (add_button, "clicked",
G_CALLBACK(pragha_open_files_dialog_add_button_cb), storage);
g_signal_connect (chooser, "file-activated",
G_CALLBACK(pragha_open_files_dialog_add_button_cb), storage);
g_signal_connect (close_button, "clicked",
G_CALLBACK(pragha_open_files_dialog_close_button_cb), window);
g_signal_connect (window, "destroy",
G_CALLBACK(gtk_widget_destroy), window);
g_signal_connect (window, "key-press-event",
G_CALLBACK(pragha_open_files_dialog_keypress), NULL);
gtk_window_set_transient_for(GTK_WINDOW (window), GTK_WINDOW(pragha_application_get_window(pragha)));
gtk_window_set_destroy_with_parent (GTK_WINDOW (window), TRUE);
gtk_widget_show_all(window);
}
static void _lib_geotagging_gpx_callback(GtkWidget *widget, dt_lib_module_t *self)
{
dt_lib_geotagging_t *d = (dt_lib_geotagging_t *)self->data;
/* bring a filechooser to select the gpx file to apply to selection */
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new(
_("open GPX file"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN, _("_cancel"), GTK_RESPONSE_CANCEL,
_("_open"), GTK_RESPONSE_ACCEPT, (char *)NULL);
char *last_directory = dt_conf_get_string("ui_last/gpx_last_directory");
if(last_directory != NULL)
{
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_directory);
g_free(last_directory);
}
GtkFileFilter *filter;
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_FILENAME | GTK_FILE_FILTER_MIME_TYPE,
_lib_geotagging_filter_gpx, NULL, NULL);
gtk_file_filter_set_name(filter, _("GPS data exchange format"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
filter = GTK_FILE_FILTER(gtk_file_filter_new());
gtk_file_filter_add_pattern(filter, "*");
gtk_file_filter_set_name(filter, _("all files"));
gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);
// add time zone selection
GtkWidget *extra_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
GtkWidget *label = gtk_label_new(_("camera time zone"));
gtk_widget_set_tooltip_text(label, _("most cameras don't store the time zone in EXIF. "
"give the correct time zone so the GPX data can be correctly matched"));
GtkWidget *tz_selection = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), "UTC");
gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), 0);
GList *iter = d->timezones;
int i = 0;
gchar *old_tz = dt_conf_get_string("plugins/lighttable/geotagging/tz");
if(iter)
{
do
{
i++;
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(tz_selection), (gchar *)iter->data);
if(!strcmp((gchar *)iter->data, old_tz)) gtk_combo_box_set_active(GTK_COMBO_BOX(tz_selection), i);
} while((iter = g_list_next(iter)) != NULL);
}
g_free(old_tz);
gtk_box_pack_start(GTK_BOX(extra_box), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(extra_box), tz_selection, FALSE, FALSE, 0);
gtk_widget_show_all(extra_box);
gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(filechooser), extra_box);
if(gtk_dialog_run(GTK_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
{
gchar *folder = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(filechooser));
dt_conf_set_string("ui_last/gpx_last_directory", folder);
g_free(folder);
gchar *tz = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(tz_selection));
dt_conf_set_string("plugins/lighttable/geotagging/tz", tz);
gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
dt_control_gpx_apply(filename, -1, tz);
g_free(filename);
g_free(tz);
}
gtk_widget_destroy(extra_box);
gtk_widget_destroy(filechooser);
// dt_control_queue_redraw_center();
}
GtkFileFilter* cast_GtkFileFilter(gpointer pointer) {
return GTK_FILE_FILTER(pointer);
}
int
main(int argc, char *argv[])
{
signal_user_data_t *ud;
GError *error = NULL;
GOptionContext *context;
#if defined(_WIN32)
// Tell gdk pixbuf where it's loader config file is.
_putenv_s("GDK_PIXBUF_MODULE_FILE", "ghb.exe.local/loaders.cache");
_putenv_s("GST_PLUGIN_PATH", "lib/gstreamer-1.0");
#endif
hb_global_init();
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#endif
context = g_option_context_new(_("- Transcode media formats"));
g_option_context_add_main_entries(context, entries, GETTEXT_PACKAGE);
g_option_context_add_group(context, gtk_get_option_group(TRUE));
#if defined(_ENABLE_GST)
g_option_context_add_group(context, gst_init_get_option_group());
#endif
g_option_context_parse(context, &argc, &argv, &error);
if (error != NULL)
{
g_warning("%s: %s", G_STRFUNC, error->message);
g_clear_error(&error);
}
g_option_context_free(context);
#if defined(_WIN32)
if (win32_console)
{
// Enable console logging
if(AttachConsole(ATTACH_PARENT_PROCESS) || AllocConsole()){
close(STDOUT_FILENO);
freopen("CONOUT$", "w", stdout);
close(STDERR_FILENO);
freopen("CONOUT$", "w", stderr);
}
}
else
{
// Non-console windows apps do not have a stderr->_file
// assigned properly
stderr->_file = STDERR_FILENO;
stdout->_file = STDOUT_FILENO;
}
#endif
if (argc > 1 && dvd_device == NULL && argv[1][0] != '-')
{
dvd_device = argv[1];
}
gtk_init(&argc, &argv);
GtkCssProvider *css = gtk_css_provider_new();
error = NULL;
gtk_css_provider_load_from_data(css, MyCSS, -1, &error);
if (error == NULL)
{
GdkScreen *ss = gdk_screen_get_default();
gtk_style_context_add_provider_for_screen(ss, GTK_STYLE_PROVIDER(css),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
else
{
g_warning("%s: %s", G_STRFUNC, error->message);
g_clear_error(&error);
}
#if !defined(_WIN32)
notify_init("HandBrake");
#endif
ghb_resource_init();
ghb_load_icons();
#if !defined(_WIN32)
dbus_g_thread_init();
#endif
ghb_udev_init();
ghb_write_pid_file();
ud = g_malloc0(sizeof(signal_user_data_t));
ud->debug = ghb_debug;
g_log_set_handler(NULL, G_LOG_LEVEL_DEBUG, debug_log_handler, ud);
g_log_set_handler("Gtk", G_LOG_LEVEL_WARNING, warn_log_handler, ud);
//g_log_set_handler("Gtk", G_LOG_LEVEL_CRITICAL, warn_log_handler, ud);
ud->globals = ghb_dict_new();
ud->prefs = ghb_dict_new();
ud->settings_array = ghb_array_new();
ud->settings = ghb_dict_new();
ghb_array_append(ud->settings_array, ud->settings);
ud->builder = create_builder_or_die(BUILDER_NAME);
// Enable events that alert us to media change events
watch_volumes(ud);
//GtkWidget *widget = GHB_WIDGET(ud->builder, "PictureDetelecineCustom");
//gtk_entry_set_inner_border(widget, 2);
// Since GtkBuilder no longer assigns object ids to widget names
// Assign a few that are necessary for style overrides to work
#if defined(_NO_UPDATE_CHECK)
GtkWidget *widget;
widget = GHB_WIDGET(ud->builder, "check_updates_box");
gtk_widget_hide(widget);
#endif
// Must set the names of the widgets that I want to modify
// style for.
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_hud"), "preview_hud");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_frame"), "preview_frame");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_preview_play"), "live_preview_play");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_preview_progress"), "live_preview_progress");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_encode_progress"), "live_encode_progress");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_duration"), "live_duration");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_show_crop"), "preview_show_crop");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_fullscreen"), "preview_fullscreen");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "activity_view"), "activity_view");
// Redirect stderr to the activity window
ghb_preview_init(ud);
IoRedirect(ud);
ghb_log( "%s - %s - %s",
HB_PROJECT_TITLE, HB_PROJECT_BUILD_TITLE, HB_PROJECT_URL_WEBSITE );
ghb_init_dep_map();
// Need to connect x264_options textview buffer to the changed signal
// since it can't be done automatically
GtkTextView *textview;
GtkTextBuffer *buffer;
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "x264Option"));
buffer = gtk_text_view_get_buffer(textview);
g_signal_connect(buffer, "changed", (GCallback)x264_entry_changed_cb, ud);
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "VideoOptionExtra"));
buffer = gtk_text_view_get_buffer(textview);
g_signal_connect(buffer, "changed", (GCallback)video_option_changed_cb, ud);
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "MetaLongDescription"));
buffer = gtk_text_view_get_buffer(textview);
g_signal_connect(buffer, "changed", (GCallback)plot_changed_cb, ud);
ghb_combo_init(ud);
g_debug("ud %p\n", ud);
g_debug("ud->builder %p\n", ud->builder);
bind_audio_tree_model(ud);
bind_subtitle_tree_model(ud);
bind_presets_tree_model(ud);
bind_queue_tree_model(ud);
bind_chapter_tree_model(ud);
// Connect up the signals to their callbacks
// I wrote my own connector so that I could pass user data
// to the callbacks. Builder's standard autoconnect doesn't all this.
gtk_builder_connect_signals_full(ud->builder, MyConnect, ud);
ghb_init_audio_defaults_ui(ud);
ghb_init_subtitle_defaults_ui(ud);
// Parsing x264 options "" initializes x264 widgets to proper defaults
ghb_x264_init(ud);
// Load prefs before presets. Some preset defaults may depend
// on preference settings.
// First load default values
ghb_settings_init(ud->prefs, "Preferences");
ghb_settings_init(ud->globals, "Globals");
ghb_settings_init(ud->settings, "Initialization");
ghb_settings_init(ud->settings, "OneTimeInitialization");
// Load user preferences file
ghb_prefs_load(ud);
// Store user preferences into ud->prefs
ghb_prefs_to_settings(ud->prefs);
int logLevel = ghb_dict_get_int(ud->prefs, "LoggingLevel");
ghb_backend_init(logLevel);
// Load the presets files
ghb_presets_load(ud);
// Note that ghb_preset_to_settings(ud->settings) is called when
// the default preset is selected.
ghb_settings_to_ui(ud, ud->globals);
ghb_settings_to_ui(ud, ud->prefs);
// Note that ghb_settings_to_ui(ud->settings) happens when initial
// empty title is initialized.
if (ghb_dict_get_bool(ud->prefs, "hbfd"))
{
ghb_hbfd(ud, TRUE);
}
const gchar *source = ghb_dict_get_string(ud->prefs, "default_source");
ghb_dvd_set_current(source, ud);
// Populate the presets tree view
ghb_presets_list_init(ud, NULL);
// Get the first preset name
if (arg_preset != NULL)
{
ghb_select_preset(ud->builder, arg_preset);
}
else
{
ghb_select_default_preset(ud->builder);
}
// Grey out widgets that are dependent on a disabled feature
ghb_check_all_depencencies(ud);
if (dvd_device != NULL)
{
// Source overridden from command line option
ghb_dict_set_string(ud->globals, "scan_source", dvd_device);
g_idle_add((GSourceFunc)ghb_idle_scan, ud);
}
else
{
GhbValue *gval = ghb_dict_get_value(ud->prefs, "default_source");
ghb_dict_set(ud->globals, "scan_source", ghb_value_dup(gval));
}
// Reload and check status of the last saved queue
g_idle_add((GSourceFunc)ghb_reload_queue, ud);
// Start timer for monitoring libhb status, 500ms
g_timeout_add(200, ghb_timer_cb, (gpointer)ud);
// Add dvd devices to File menu
ghb_volname_cache_init();
GHB_THREAD_NEW("Cache Volume Names", (GThreadFunc)ghb_cache_volnames, ud);
GtkWidget *ghb_window = GHB_WIDGET(ud->builder, "hb_window");
gint window_width, window_height;
GdkGeometry geo = {
-1, -1, 1920, 768, -1, -1, 10, 10, 0, 0, GDK_GRAVITY_NORTH_WEST
};
GdkWindowHints geo_mask;
geo_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE;
gtk_window_set_geometry_hints(GTK_WINDOW(ghb_window), ghb_window,
&geo, geo_mask);
window_width = ghb_dict_get_int(ud->prefs, "window_width");
window_height = ghb_dict_get_int(ud->prefs, "window_height");
/*
* Filter objects in GtkBuilder xml
* Unfortunately, GtkFilter is poorly supported by GtkBuilder,
* so a lot of the setup must happen in code.
SourceFilterAll
SourceFilterVideo
SourceFilterTS
SourceFilterMPG
SourceFilterEVO
SourceFilterVOB
SourceFilterMKV
SourceFilterMP4
SourceFilterAVI
SourceFilterMOV
SourceFilterOGG
SourceFilterFLV
SourceFilterWMV
*/
// Add filters to source chooser
GtkFileFilter *filter;
GtkFileChooser *chooser;
chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "source_dialog"));
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_filter_set_name(filter, _("All"));
gtk_file_filter_add_pattern(filter, "*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVideo"));
gtk_file_filter_set_name(filter, _("Video"));
gtk_file_filter_add_mime_type(filter, "video/*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterTS"));
gtk_file_filter_set_name(filter, "TS");
gtk_file_filter_add_pattern(filter, "*.ts");
gtk_file_filter_add_pattern(filter, "*.TS");
gtk_file_filter_add_pattern(filter, "*.m2ts");
gtk_file_filter_add_pattern(filter, "*.M2TS");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMPG"));
gtk_file_filter_set_name(filter, "MPG");
gtk_file_filter_add_pattern(filter, "*.mpg");
gtk_file_filter_add_pattern(filter, "*.MPG");
gtk_file_filter_add_pattern(filter, "*.mepg");
gtk_file_filter_add_pattern(filter, "*.MEPG");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterEVO"));
gtk_file_filter_set_name(filter, "EVO");
gtk_file_filter_add_pattern(filter, "*.evo");
gtk_file_filter_add_pattern(filter, "*.EVO");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVOB"));
gtk_file_filter_set_name(filter, "VOB");
gtk_file_filter_add_pattern(filter, "*.vob");
gtk_file_filter_add_pattern(filter, "*.VOB");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMKV"));
gtk_file_filter_set_name(filter, "MKV");
gtk_file_filter_add_pattern(filter, "*.mkv");
gtk_file_filter_add_pattern(filter, "*.MKV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMP4"));
gtk_file_filter_set_name(filter, "MP4");
gtk_file_filter_add_pattern(filter, "*.mp4");
gtk_file_filter_add_pattern(filter, "*.MP4");
gtk_file_filter_add_pattern(filter, "*.m4v");
gtk_file_filter_add_pattern(filter, "*.M4V");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMOV"));
gtk_file_filter_set_name(filter, "MOV");
gtk_file_filter_add_pattern(filter, "*.mov");
gtk_file_filter_add_pattern(filter, "*.MOV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAVI"));
gtk_file_filter_set_name(filter, "AVI");
gtk_file_filter_add_pattern(filter, "*.avi");
gtk_file_filter_add_pattern(filter, "*.AVI");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterOGG"));
gtk_file_filter_set_name(filter, "OGG");
gtk_file_filter_add_pattern(filter, "*.ogg");
gtk_file_filter_add_pattern(filter, "*.OGG");
gtk_file_filter_add_pattern(filter, "*.ogv");
gtk_file_filter_add_pattern(filter, "*.OGV");
gtk_file_filter_add_pattern(filter, "*.ogm");
gtk_file_filter_add_pattern(filter, "*.OGM");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterFLV"));
gtk_file_filter_set_name(filter, "FLV");
gtk_file_filter_add_pattern(filter, "*.flv");
gtk_file_filter_add_pattern(filter, "*.FLV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterWMV"));
gtk_file_filter_set_name(filter, "WMV");
gtk_file_filter_add_pattern(filter, "*.wmv");
gtk_file_filter_add_pattern(filter, "*.WMV");
gtk_file_chooser_add_filter(chooser, filter);
// Gtk has a really stupid bug. If the file chooser is showing
// hidden files AND there is no filter set, it will not select
// the filename when gtk_file_chooser_set_filename is called.
// So add a completely unnessary filter to prevent this behavior.
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_chooser_set_filter(chooser, filter);
#if !GTK_CHECK_VERSION(3, 16, 0)
PangoFontDescription *font_desc;
font_desc = pango_font_description_from_string("monospace 10");
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "activity_view"));
gtk_widget_override_font(GTK_WIDGET(textview), font_desc);
pango_font_description_free(font_desc);
#endif
// Grrrr! Gtk developers !!!hard coded!!! the width of the
// radio buttons in GtkStackSwitcher to 100!!!
//
// Thankfully, GtkStackSwitcher is a regular container object
// and we can access the buttons to change their width.
GList *stack_switcher_children, *link;
GtkContainer * stack_switcher = GTK_CONTAINER(
GHB_WIDGET(ud->builder, "SettingsStackSwitcher"));
link = stack_switcher_children = gtk_container_get_children(stack_switcher);
while (link != NULL)
{
GtkWidget *widget = link->data;
gtk_widget_set_size_request(widget, -1, -1);
gtk_widget_set_hexpand(widget, TRUE);
gtk_widget_set_halign(widget, GTK_ALIGN_FILL);
link = link->next;
}
g_list_free(stack_switcher_children);
gtk_window_resize(GTK_WINDOW(ghb_window), window_width, window_height);
gtk_widget_show(ghb_window);
// Everything should be go-to-go. Lets rock!
gtk_main();
ghb_backend_close();
ghb_value_free(&ud->queue);
ghb_value_free(&ud->settings_array);
ghb_value_free(&ud->prefs);
ghb_value_free(&ud->globals);
ghb_value_free(&ud->x264_priv);
g_io_channel_unref(ud->activity_log);
ghb_settings_close();
ghb_resource_free();
#if !defined(_WIN32)
notify_uninit();
#endif
g_object_unref(ud->builder);
g_free(ud->current_dvd_device);
g_free(ud);
return 0;
}
