static int
parse_config(gnc_t gnc, void *closure)
{
int c;
char *token;
c = gnc(closure);
if(c < 2)
return -1;
while(c >= 0) {
c = skip_whitespace(c, gnc, closure);
if(c == '\n' || c == '#') {
c = skip_to_eol(c, gnc, closure);
continue;
}
if(c < 0)
break;
c = getword(c, &token, gnc, closure);
if(c < -1)
return -1;
if(strcmp(token, "in") == 0) {
struct filter *filter;
filter = parse_filter(gnc, closure);
if(filter == NULL)
return -1;
add_filter(filter, &input_filters);
} else if(strcmp(token, "out") == 0) {
struct filter *filter;
filter = parse_filter(gnc, closure);
if(filter == NULL)
return -1;
add_filter(filter, &output_filters);
} else if(strcmp(token, "redistribute") == 0) {
struct filter *filter;
filter = parse_filter(gnc, closure);
if(filter == NULL)
return -1;
add_filter(filter, &redistribute_filters);
} else if(strcmp(token, "interface") == 0) {
struct network_conf *nconf;
nconf = parse_nconf(gnc, closure);
if(nconf == NULL)
return -1;
add_nconf(nconf, &network_confs);
} else {
return -1;
}
free(token);
}
return 1;
}
void ObjectSelectionPage::setup_filters()
{
Db_plugin *plugin= ((WbPluginDbImport*)_form)->db_plugin();
bool empty= true;
reset();
_filters.clear();
if (plugin->db_objects_selection_model(Db_plugin::dbotTable)->total_items_count() > 0)
{
_filters[Db_plugin::dbotTable]=
add_filter(plugin->db_objects_struct_name_by_type(Db_plugin::dbotTable),
_("Import %s Objects"),
plugin->db_objects_selection_model(Db_plugin::dbotTable),
plugin->db_objects_exclusion_model(Db_plugin::dbotTable),
plugin->db_objects_enabled_flag(Db_plugin::dbotTable));
empty= false;
}
if (plugin->db_objects_selection_model(Db_plugin::dbotView)->total_items_count() > 0)
{
_filters[Db_plugin::dbotView]=
add_filter(plugin->db_objects_struct_name_by_type(Db_plugin::dbotView),
_("Import %s Objects"),
plugin->db_objects_selection_model(Db_plugin::dbotView),
plugin->db_objects_exclusion_model(Db_plugin::dbotView),
plugin->db_objects_enabled_flag(Db_plugin::dbotView));
empty= false;
}
if (plugin->db_objects_selection_model(Db_plugin::dbotRoutine)->total_items_count() > 0)
{
_filters[Db_plugin::dbotRoutine]=
add_filter(plugin->db_objects_struct_name_by_type(Db_plugin::dbotRoutine),
_("Import %s Objects"),
plugin->db_objects_selection_model(Db_plugin::dbotRoutine),
plugin->db_objects_exclusion_model(Db_plugin::dbotRoutine),
plugin->db_objects_enabled_flag(Db_plugin::dbotRoutine));
empty= false;
}
if (plugin->db_objects_selection_model(Db_plugin::dbotTrigger)->total_items_count() > 0)
{
_filters[Db_plugin::dbotTrigger]=
add_filter(plugin->db_objects_struct_name_by_type(Db_plugin::dbotTrigger),
_("Import %s Objects"),
plugin->db_objects_selection_model(Db_plugin::dbotTrigger),
plugin->db_objects_exclusion_model(Db_plugin::dbotTrigger),
plugin->db_objects_enabled_flag(Db_plugin::dbotTrigger));
empty= false;
}
_empty_label.show(empty);
}
static DBusMessage *pbap_set_filter(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct pbap_data *pbap = user_data;
char **filters, **item;
gint size;
uint64_t oldfilter = pbap->filter;
if (dbus_message_get_args(message, NULL, DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING, &filters, &size,
DBUS_TYPE_INVALID) == FALSE)
return g_dbus_create_error(message,
ERROR_INF ".InvalidArguments", NULL);
remove_filter(pbap, "ALL");
if (size == 0)
goto done;
for (item = filters; *item; item++) {
if (add_filter(pbap, *item) < 0) {
pbap->filter = oldfilter;
g_strfreev(filters);
return g_dbus_create_error(message,
ERROR_INF ".InvalidArguments", "InvalidFilters");
}
}
done:
g_strfreev(filters);
return dbus_message_new_method_return(message);
}
int
finalise_config()
{
struct filter *filter = calloc(1, sizeof(struct filter));
if(filter == NULL)
return -1;
filter->proto = RTPROT_BABEL_LOCAL;
filter->plen_le = 128;
add_filter(filter, &redistribute_filters);
while(network_confs) {
struct network_conf *n;
void *vrc;
n = network_confs;
network_confs = network_confs->next;
n->next = NULL;
vrc = add_network(n->ifname, n);
if(vrc == NULL) {
fprintf(stderr, "Couldn't add interface %s.\n", n->ifname);
return -1;
}
}
return 1;
}
static const char *filter_bytype1(cmd_parms *cmd, void *CFG,
const char *pname, const char **types)
{
const char *rv;
const char *fname;
int seen_name = 0;
mod_filter_cfg *cfg = CFG;
/* construct fname from name */
fname = apr_pstrcat(cmd->pool, "BYTYPE:", pname, NULL);
/* check whether this is already registered, in which case
* it's already in the filter chain
*/
if (apr_hash_get(cfg->live_filters, fname, APR_HASH_KEY_STRING)) {
seen_name = 1;
}
rv = add_filter(cmd, CFG, fname, pname, NULL, types);
/* If it's the first time through, add to filterchain */
if (rv == NULL && !seen_name) {
rv = filter_chain(cmd, CFG, fname);
}
return rv;
}
void monitor::set_filters(const std::vector<monitor_filter>& filters)
{
for (const monitor_filter& filter : filters)
{
add_filter(filter);
}
}
int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
add_filter();
start_trema();
}
Filter::Filter(QWidget *parent) : QWidget(), ui(new Ui::filter)
{
settings = static_cast<DFRSSFilter*>(parent)->settings;
lineEdit = new QLineEdit(this);
filters.clear();
lineEdit->setPlaceholderText("Введите фильтр...");
QPushButton *add_button = new QPushButton; // добавить фильтр
add_button->setText("Добавить");
QPushButton *del_button = new QPushButton; // удалить фильтр
del_button->setText("Удалить");
QPushButton *check_all_button = new QPushButton; // выбрать все
check_all_button->setText("Выбрать все");
QPushButton *uncheck_all_button = new QPushButton; // снять выбор
uncheck_all_button->setText("Отменить все");
filter_hint = new QLabel(this);
filers_list = new QTreeWidget(this);
filers_list->setSelectionMode(QAbstractItemView::ExtendedSelection); // чтобы можно было выделять несколько элементов с помощью Ctrl и Shift
set_filters_header_label();
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// здесь решается вопрос растяжения - нужно его решить
filers_list->header()->setSectionResizeMode(QHeaderView::ResizeToContents);
filers_list->header()->hide(); // скроем заголовок таблицы - он нафиг не нужен
show_filters(filers_list, filters);
choice_hint = new QLabel(this);
choice_hint->setText("Используйте Ctrl и Shift для множественного выделения удаляемых фильтров");
QHBoxLayout *h_layout = new QHBoxLayout; //
h_layout->addWidget(lineEdit);
h_layout->addWidget(add_button);
h_layout->addWidget(del_button);
QHBoxLayout *bottom_h_layout = new QHBoxLayout; // нижний
bottom_h_layout->addWidget(choice_hint);
bottom_h_layout->addWidget(check_all_button);
bottom_h_layout->addWidget(uncheck_all_button);
QVBoxLayout *v_layout = new QVBoxLayout; //
v_layout->addLayout(h_layout);
v_layout->addWidget(filter_hint);
v_layout->addWidget(filers_list);
v_layout->addLayout(bottom_h_layout);
setLayout(v_layout); // установка главного лэйаута
resize(640,480);
// соединим кнопки с функциями
connect(add_button, SIGNAL(clicked()), this, SLOT(add_filter())); //
connect(del_button, SIGNAL(clicked()), this, SLOT(del_filter())); //
connect(check_all_button, SIGNAL(clicked()), this, SLOT(check_all())); //
connect(uncheck_all_button, SIGNAL(clicked()), this, SLOT(uncheck_all())); //
//connect(lineEdit, SIGNAL(returnPressed()), this, SLOT(add_filter())); // добавление по нажатию клавиши ENTER
this->setWindowIcon(QIcon(":/filter.ico"));
}
void monitor::set_filters(const std::vector<monitor_filter> &filters)
{
#ifdef HAVE_REGCOMP
for (const monitor_filter &filter : filters)
{
add_filter(filter);
}
#endif
}
OpenFileDialog::OpenFileDialog(Gtk::Window& parent)
: FileChooserNative{parent,
_("Open document"),
GTK_FILE_CHOOSER_ACTION_OPEN,
_("Open"),
_("Cancel")}
{
set_select_multiple(false);
add_filter(pdfFilter());
}
char* io::plugin::getfilter(char* result)
{
result[0] = 0;
for(auto p = first; p; p = p->next)
{
if(!p->name)
continue;
result = add_filter(result, p->fullname, p->filter);
}
return result;
}
static void add_filter(codadump_filter **filter, codadump_filter *new_filter)
{
assert(filter != NULL);
if (new_filter == NULL)
{
return;
}
if (*filter == NULL)
{
*filter = new_filter;
return;
}
if (strcmp((*filter)->fieldname, new_filter->fieldname) == 0)
{
if ((*filter)->subfilter != NULL)
{
if (new_filter->subfilter != NULL)
{
add_filter(&(*filter)->subfilter, new_filter->subfilter);
new_filter->subfilter = NULL;
}
else
{
codadump_filter_remove(&(*filter)->subfilter);
}
}
codadump_filter_remove(&new_filter);
return;
}
else if ((*filter)->next != NULL)
{
add_filter(&(*filter)->next, new_filter);
}
else
{
(*filter)->next = new_filter;
}
}
void genericFilechooserWindow::setAllFilesFilter
(
void
)
{
// no filter -> all files
Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
filter->set_name("All files");
filter->add_pattern("*");
// add the filters to the filechooser
add_filter(filter);
}
void openlog(const char* facility, Filter_Base* filter)
{
std::lock_guard<std::recursive_mutex> lock(mutex_);
if (facility)
thread_log_settings_table_[std::hash<std::thread::id>()(std::this_thread::get_id())].facility_ = facility;
else
return;
if (filter)
add_filter(filter);
}
void parse::process_pmt(const decoded_pmt_t *pmt)
{
dprintf(": v%d, service_id %d, pcr_pid %d",
pmt->version, pmt->program, pmt->pcr_pid);
for (map_ts_elementary_streams::const_iterator iter_pmt_es = pmt->es_streams.begin();
iter_pmt_es != pmt->es_streams.end(); ++iter_pmt_es) {
/* if we're going to stream a program, make sure its pid is coming thru */
payload_pids[iter_pmt_es->second.pid] = iter_pmt_es->second.type;
add_filter(iter_pmt_es->second.pid);
}
}
/**
* Program entry point. Initializes gtk+, calls the widget creating
* functions and starts the main loop. Also connects 'popup-menu',
* 'activate' and 'button-release-event' to the tray_icon.
*
* @param argc count of arguments
* @param argv string array of arguments
* @return 0 for success, otherwise error code
*/
int main (int argc, char *argv[]) {
GError *error = NULL;
GOptionContext *context;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
DEBUG_PRINT("[Debugging Mode Build]\n");
setlocale(LC_ALL, "");
context = g_option_context_new (_("- A mixer for the system tray."));
g_option_context_add_main_entries (context, args, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_parse (context, &argc, &argv, &error);
gtk_init (&argc, &argv);
g_option_context_free(context);
if (version) {
printf(_("%s version: %s\n"),PACKAGE,VERSION);
exit(0);
}
popup_window = NULL;
status_icons[0] = status_icons[1] = status_icons[2] = status_icons[3] = NULL;
add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");
add_pixmap_directory ("./pixmaps");
ensure_prefs_dir();
load_prefs();
cards = NULL; // so we don't try and free on first run
alsa_init();
init_libnotify();
create_popups();
add_filter();
tray_icon = create_tray_icon();
apply_prefs(0);
g_signal_connect(G_OBJECT(tray_icon), "popup-menu",G_CALLBACK(popup_callback), popup_menu);
g_signal_connect(G_OBJECT(tray_icon), "activate", G_CALLBACK(tray_icon_on_click), NULL);
g_signal_connect(G_OBJECT(tray_icon), "button-release-event", G_CALLBACK(tray_icon_button), NULL);
gtk_main ();
uninit_libnotify();
alsa_close();
return 0;
}
void genericFilechooserWindow::setXMLEBUCoreFilter
(
void
)
{
// filter for XML ebucore files
Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
filter->set_name("XML EBUCore");
filter->add_pattern("*.xml");
// add the filters to the filechooser
add_filter(filter);
}
void genericFilechooserWindow::setPlaylistFilter
(
void
)
{
// filter for playlist files
Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
filter->set_name("Playlist");
filter->add_pattern("*.m3u");
// add the filters to the filechooser
add_filter(filter);
}
/*
=================
G_AddIP_f
=================
*/
void G_AddIP_f(edict_t *ent)
{
unsigned mask, compare;
unsigned duration;
ipaction_t action;
int start, argc;
char *s;
start = ent ? 0 : 1;
argc = gi.argc() - start;
if (argc < 2) {
gi.cprintf(ent, PRINT_HIGH, "Usage: %s <ip-mask> [duration] [action]\n", gi.argv(start));
return;
}
if (numipfilters == MAX_IPFILTERS) {
gi.cprintf(ent, PRINT_HIGH, "IP filter list is full\n");
return;
}
s = gi.argv(start + 1);
if (!parse_filter(s, &mask, &compare)) {
gi.cprintf(ent, PRINT_HIGH, "Bad filter address: %s\n", s);
return;
}
duration = ent ? DEF_DURATION : 0;
action = IPA_BAN;
if (argc > 2) {
s = gi.argv(start + 2);
duration = parse_duration(s);
if (ent) {
if (!duration) {
gi.cprintf(ent, PRINT_HIGH, "You may not add permanent bans.\n");
return;
}
if (duration > MAX_DURATION) {
duration = MAX_DURATION;
}
}
if (argc > 3) {
s = gi.argv(start + 3);
action = parse_action(s);
if (action == IPA_NONE) {
gi.cprintf(ent, PRINT_HIGH, "Bad action specifier: %s\n", s);
return;
}
}
}
add_filter(action, mask, compare, duration, ent);
}
void G_BanEdict(edict_t *victim, edict_t *initiator)
{
unsigned mask, compare;
if (numipfilters == MAX_IPFILTERS) {
return;
}
if (!parse_filter(victim->client->pers.ip, &mask, &compare)) {
return;
}
add_filter(IPA_BAN, mask, compare, DEF_DURATION, initiator);
}
void filechooserDialog::setXMLFilter
(
void
)
{
// filter for any xml files
Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
filter->set_name("Any XML source");
filter->add_mime_type("text/xml");//xml mime type
filter->add_pattern("*.xml");
// add the filters to the filechooser
add_filter(filter);
}
int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
init_packetin_filter_interface();
add_periodic_event_callback( 5, timeout, NULL );
add_filter();
start_trema();
finalize_packetin_filter_interface();
}
Connection::Connection( DBusBusType type )
{
Error e;
_connection = dbus_bus_get(type,e);
if(e) throw e;
_disconn_filter.filtered.connect( sigc::mem_fun(*this, &Connection::_disconn_filter_function) );
add_filter(_disconn_filter);
init();
}
void genericFilechooserWindow::setAVCITextFilter
(
void
)
{
// filter for any raw AVC-Intra text files
Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
filter->set_name("AVC-Intra Text");
filter->add_pattern("*.txt");
filter->add_pattern("*.dat");
// add the filters to the filechooser
add_filter(filter);
}
void genericFilechooserWindow::setMXFFilter
(
void
)
{
// filter for MXF files
Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
filter->set_name("MXF Container");
filter->add_mime_type("application/mxf");//MXF Container
filter->add_pattern("*.mxf");
// add the filters to the filechooser
add_filter(filter);
}
int main(int argc, char *argv[])
{
int dvrfd, tsfd;
unsigned int pid;
char *dmxdev = "/dev/dvb/adapter0/demux0";
char *dvrdev = "/dev/dvb/adapter0/dvr0";
int i;
char *chkp;
if (argc < 3)
usage();
if (getenv("DEMUX"))
dmxdev = getenv("DEMUX");
if (getenv("DVR"))
dvrdev = getenv("DVR");
fprintf(stderr, "using '%s' and '%s'\n"
"writing to '%s'\n", dmxdev, dvrdev, argv[1]);
tsfd = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0664);
if (tsfd == -1) {
perror("cannot write output file");
return 1;
}
dvrfd = open(dvrdev, O_RDONLY);
if (dvrfd == -1) {
perror("cannot open dvr device");
return 1;
}
if (getenv("BUF_SIZE") && ((BUF_SIZE = strtoul(getenv("BUF_SIZE"), NULL, 0)) > 0))
fprintf(stderr, "BUF_SIZE = %lu\n", BUF_SIZE);
for (i = 2; i < argc; i++) {
pid = strtoul(argv[i], &chkp, 0);
if (pid > 0x2000 || chkp == argv[i])
usage();
fprintf(stderr, "adding filter for PID 0x%04x\n", pid);
//FIXME: stop & close filters later...
if (add_filter(pid, dmxdev) != 0)
return 1;
}
for (;;) {
process_data(dvrfd, tsfd);
}
close(dvrfd);
return 0;
}
void filechooserDialog::setBiMFilter
(
void
)
{
// filter for any bin files
Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
filter->set_name("Any BiM source");
filter->add_mime_type("application/octet-stream");// RFC2046
filter->add_pattern("*.bin");
filter->add_pattern("*.txt");
// add the filters to the filechooser
add_filter(filter);
}
void genericFilechooserWindow::setAnyEBUCoreFilter
(
void
)
{
// filter for any ebucore files
Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
filter->set_name("Any EBUCore source");
filter->add_mime_type("application/mxf");//MXF Container mime type
filter->add_mime_type("text/xml");//xml mime type
filter->add_pattern("*.xml");
filter->add_pattern("*.mxf");
// add the filters to the filechooser
add_filter(filter);
}
void genericFilechooserWindow::setVideoFilter
(
void
)
{
// filter for video files
Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
filter->set_name("Video");
filter->add_mime_type("video/*");
// RAW Video types
filter->add_mime_type("video/x-raw-yuv");//YUV or YCbCr video
filter->add_mime_type("video/x-raw-rgb");//RGB video
// Encoded Video types
filter->add_mime_type("video/x-3ivx"); //3ivx video
filter->add_mime_type("video/x-divx"); //divx video
filter->add_mime_type("video/x-dv"); //digital video
filter->add_mime_type("video/x-ffv");//ffmpeg video
filter->add_mime_type("video/x-h263");//H.263 video
filter->add_mime_type("video/x-h264");//H.264 video
filter->add_mime_type("video/x-huffyuv");//Huffyuv video
filter->add_mime_type("video/x-indeo");//Indeo video
filter->add_mime_type("video/x-intel-h263");//H.263 video Intel variant
filter->add_mime_type("video/x-intel-h263");//Motion JPEG video
filter->add_mime_type("video/x-jpeg");//H.263 video Intel variant
filter->add_mime_type("video/mpeg");//MPEG video
filter->add_mime_type("video/x-msmpeg");//MPEG4 Microsoft variant
filter->add_mime_type("video/x-msvideocodec");//Microsoft Video 1
filter->add_mime_type("video/x-pn-realvideo");//Realmedia video
filter->add_mime_type("video/x-rle");//RLE Animation video
filter->add_mime_type("video/x-svq");//Sorenson video
filter->add_mime_type("video/x-tarkin");//Tarkin video
filter->add_mime_type("video/x-rle");//Theora video
filter->add_mime_type("video/x-theora");//RLE Animation video
filter->add_mime_type("video/x-vp3");//VP3 video
filter->add_mime_type("video/x-wmv");//Windows Media Video
filter->add_mime_type("video/x-xvid");//Xvid video
//Multimedia/Video Container types
filter->add_mime_type("video/x-ms-asf");//Advanced Streaming Format
filter->add_mime_type("video/x-msvideo");//AVI Container
filter->add_mime_type("video/x-matroska");//Matroska (MKV)
filter->add_mime_type("video/ogg");//Ogg container
filter->add_mime_type("video/quicktime");//Apple container
filter->add_mime_type("video/vnd.rn-realmedia");//Realmedia container
filter->add_mime_type("application/mxf");//MXF Container
// add the filters to the filechooser
add_filter(filter);
}
void genericFilechooserWindow::setAudioFilter
(
void
)
{
// filter for audio files
Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
filter->set_name("Audio");
filter->add_mime_type("audio/*");
filter->add_pattern("*.mp3");
filter->add_pattern("*.ogg");
filter->add_pattern("*.wav");
filter->add_pattern("*.wma");
filter->add_pattern("*.pcm");
// add the filters to the filechooser
add_filter(filter);
}
