void ProfileDialog::on_buttonBox_accepted()
{
const gchar *err_msg;
QTreeWidgetItem *item = pd_ui_->profileTreeWidget->currentItem();
if ((err_msg = apply_profile_changes()) != NULL) {
QMessageBox::critical(this, tr("Profile Error"),
err_msg,
QMessageBox::Ok);
g_free((gchar*)err_msg);
return;
}
if (item) {
profile_def *profile = (profile_def *) item->data(0, Qt::UserRole).value<GList *>()->data;
if (profile_exists (profile->name, FALSE) || profile_exists (profile->name, TRUE)) {
/* The new profile exists, change */
wsApp->setConfigurationProfile (profile->name);
} else if (!profile_exists (get_profile_name(), FALSE)) {
/* The new profile does not exist, and the previous profile has
been deleted. Change to the default profile */
wsApp->setConfigurationProfile (NULL);
}
}
}
static void
profile_select(GtkWidget *main_w, GtkTreeView *profile_l, gboolean destroy)
{
GList *fl_entry;
profile_def *profile;
GtkTreeSelection *sel;
GtkTreeModel *model;
GtkTreeIter iter;
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(profile_l));
if (gtk_tree_selection_get_selected(sel, &model, &iter)) {
gtk_tree_model_get(model, &iter, 1, &fl_entry, -1);
if (fl_entry) {
profile = (profile_def *) fl_entry->data;
if (profile_exists (profile->name)) {
/* The new profile exists, change */
change_configuration_profile (profile->name);
} else if (!profile_exists (get_profile_name())) {
/* The new profile does not exist, and the previous profile has
been deleted. Change to the default profile */
change_configuration_profile (NULL);
}
}
}
if (destroy) {
/*
* Destroy the profile dialog box.
*/
empty_profile_list (TRUE);
window_destroy(main_w);
}
}
static GtkTreeIter *
fill_list(GtkWidget *main_w)
{
GList *fl_entry;
profile_def *profile;
GtkTreeView *profile_l;
GtkListStore *store;
GtkTreeIter iter, *l_select = NULL;
const gchar *profile_name = get_profile_name();
profile_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(main_w), E_PROF_PROFILE_L_KEY));
store = GTK_LIST_STORE(gtk_tree_view_get_model(profile_l));
init_profile_list();
fl_entry = edited_profile_list();
while (fl_entry && fl_entry->data) {
profile = (profile_def *)fl_entry->data;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, NAME_COLUMN, profile->name, GLOBAL_COLUMN, profile->is_global, DATA_COLUMN, fl_entry, -1);
if (profile->name && (strcmp(profile_name, profile->name) == 0)) {
/*
* XXX - We're assuming that we can just copy a GtkTreeIter
* and use it later without any crashes. This may not be a
* valid assumption.
*/
l_select = (GtkTreeIter *)g_memdup(&iter, sizeof(iter));
}
fl_entry = g_list_next(fl_entry);
}
return l_select;
}
DDSDataReader *
DDS_Subscriber_i::create_datareader_with_profile (
DDSTopic * topic,
const char * qos_profile,
DDSDataReaderListener * ccm_dds_drl,
::DDS::StatusMask mask)
{
char * lib_name = get_library_name (qos_profile);
char * prof_name = get_profile_name (qos_profile);
DDSDataReader * dr = 0;
if (lib_name != 0 && prof_name != 0)
{
dr = this->rti_entity ()->create_datareader_with_profile (topic,
lib_name,
prof_name,
ccm_dds_drl,
mask);
}
ACE_OS::free (lib_name);
ACE_OS::free (prof_name);
return dr;
}
static GtkTreeIter *
fill_list(GtkWidget *main_w)
{
WS_DIR *dir; /* scanned directory */
WS_DIRENT *file; /* current file */
GList *fl_entry;
profile_def *profile;
GtkTreeView *profile_l;
GtkListStore *store;
GtkTreeIter iter, *l_select = NULL;
const gchar *profile_name = get_profile_name ();
const gchar *profiles_dir, *name;
gchar *filename;
profile_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(main_w), E_PROF_PROFILE_L_KEY));
store = GTK_LIST_STORE(gtk_tree_view_get_model(profile_l));
fl_entry = add_to_profile_list(DEFAULT_PROFILE, DEFAULT_PROFILE, PROF_STAT_DEFAULT);
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, DEFAULT_PROFILE, 1, fl_entry, -1);
if (strcmp (profile_name, DEFAULT_PROFILE)==0) {
l_select = g_memdup(&iter, sizeof(iter));
}
/* fill in data */
profiles_dir = get_profiles_dir();
if ((dir = ws_dir_open(profiles_dir, 0, NULL)) != NULL) {
while ((file = ws_dir_read_name(dir)) != NULL) {
name = ws_dir_get_name(file);
filename = g_strdup_printf ("%s%s%s", profiles_dir, G_DIR_SEPARATOR_S, name);
if (test_for_directory(filename) == EISDIR) {
fl_entry = add_to_profile_list(name, name, PROF_STAT_EXISTS);
profile = (profile_def *) fl_entry->data;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, profile->name, 1, fl_entry, -1);
if (profile->name) {
if (strcmp(profile_name, profile->name) == 0) {
/*
* XXX - We're assuming that we can just copy a GtkTreeIter
* and use it later without any crashes. This may not be a
* valid assumption.
*/
l_select = g_memdup(&iter, sizeof(iter));
}
}
}
g_free (filename);
}
ws_dir_close (dir);
}
/* Make the current list and the edited list equal */
copy_profile_list ();
return l_select;
}
ProfileDialog::ProfileDialog(QWidget *parent) :
GeometryStateDialog(parent),
pd_ui_(new Ui::ProfileDialog),
ok_button_(NULL)
{
GList *fl_entry;
profile_def *profile;
const gchar *profile_name = get_profile_name();
pd_ui_->setupUi(this);
loadGeometry();
setWindowTitle(wsApp->windowTitleString(tr("Configuration Profiles")));
ok_button_ = pd_ui_->buttonBox->button(QDialogButtonBox::Ok);
// XXX - Use NSImageNameAddTemplate and NSImageNameRemoveTemplate to set stock
// icons on macOS.
// Are there equivalent stock icons on Windows?
#ifdef Q_OS_MAC
pd_ui_->newToolButton->setAttribute(Qt::WA_MacSmallSize, true);
pd_ui_->deleteToolButton->setAttribute(Qt::WA_MacSmallSize, true);
pd_ui_->copyToolButton->setAttribute(Qt::WA_MacSmallSize, true);
pd_ui_->infoLabel->setAttribute(Qt::WA_MacSmallSize, true);
#endif
init_profile_list();
fl_entry = edited_profile_list();
pd_ui_->profileTreeWidget->blockSignals(true);
while (fl_entry && fl_entry->data) {
profile = (profile_def *) fl_entry->data;
QTreeWidgetItem *item = new QTreeWidgetItem(pd_ui_->profileTreeWidget);
item->setText(0, profile->name);
item->setData(0, Qt::UserRole, VariantPointer<GList>::asQVariant(fl_entry));
if (profile->is_global || profile->status == PROF_STAT_DEFAULT) {
QFont ti_font = item->font(0);
ti_font.setItalic(true);
item->setFont(0, ti_font);
} else {
item->setFlags(item->flags() | Qt::ItemIsEditable);
}
if (!profile->is_global && strcmp(profile_name, profile->name) == 0) {
pd_ui_->profileTreeWidget->setCurrentItem(item);
}
fl_entry = g_list_next(fl_entry);
}
pd_ui_->profileTreeWidget->blockSignals(false);
connect(pd_ui_->profileTreeWidget->itemDelegate(), SIGNAL(closeEditor(QWidget*, QAbstractItemDelegate::EndEditHint)),
this, SLOT(editingFinished()));
updateWidgets();
}
void ProfileDialog::on_buttonBox_accepted()
{
gchar *err_msg;
QTreeWidgetItem *default_item = pd_ui_->profileTreeWidget->topLevelItem(0);
QTreeWidgetItem *item = pd_ui_->profileTreeWidget->currentItem();
gchar *profile_name = NULL;
bool write_recent = true;
bool item_data_removed = false;
if (default_item && default_item->font(0).strikeOut()) {
// Reset Default profile.
GList *fl_entry = VariantPointer<GList>::asPtr(default_item->data(0, Qt::UserRole));
remove_from_profile_list(fl_entry);
// Don't write recent file if leaving the Default profile after this has been reset.
write_recent = !is_default_profile();
// Don't fetch profile data if removed.
item_data_removed = (item == default_item);
}
if (write_recent) {
/* Get the current geometry, before writing it to disk */
wsApp->emitAppSignal(WiresharkApplication::ProfileChanging);
/* Write recent file for current profile now because
* the profile may be renamed in apply_profile_changes() */
write_profile_recent();
}
if ((err_msg = apply_profile_changes()) != NULL) {
QMessageBox::critical(this, tr("Profile Error"),
err_msg,
QMessageBox::Ok);
g_free(err_msg);
return;
}
if (item && !item_data_removed) {
profile_def *profile = (profile_def *) VariantPointer<GList>::asPtr(item->data(0, Qt::UserRole))->data;
profile_name = profile->name;
}
if (profile_exists (profile_name, FALSE) || profile_exists (profile_name, TRUE)) {
// The new profile exists, change.
wsApp->setConfigurationProfile (profile_name, FALSE);
} else if (!profile_exists (get_profile_name(), FALSE)) {
// The new profile does not exist, and the previous profile has
// been deleted. Change to the default profile.
wsApp->setConfigurationProfile (NULL, FALSE);
}
}
/*
* update the packets statusbar to the current values
*/
void
profile_bar_update(void)
{
if (profile_bar) {
/* remove old status */
if(profile_str) {
g_free(profile_str);
gtk_statusbar_pop(GTK_STATUSBAR(profile_bar), profile_ctx);
}
profile_str = g_strdup_printf (" Profile: %s", get_profile_name ());
gtk_statusbar_push(GTK_STATUSBAR(profile_bar), profile_ctx, profile_str);
}
}
void MainStatusBar::pushProfileName()
{
const gchar *cur_profile = get_profile_name();
QString status = tr("Profile: ") + cur_profile;
popProfileStatus();
pushProfileStatus(status);
if (profile_exists(cur_profile, FALSE) && strcmp (cur_profile, DEFAULT_PROFILE) != 0) {
edit_action_->setEnabled(true);
delete_action_->setEnabled(true);
} else {
edit_action_->setEnabled(false);
delete_action_->setEnabled(false);
}
}
gboolean delete_current_profile(void) {
const gchar *name = get_profile_name();
char *pf_dir_path;
if (profile_exists(name, FALSE) && strcmp (name, DEFAULT_PROFILE) != 0) {
if (delete_persconffile_profile(name, &pf_dir_path) == -1) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"Can't delete profile directory\n\"%s\":\n%s.",
pf_dir_path, g_strerror(errno));
g_free(pf_dir_path);
} else {
return TRUE;
}
}
return FALSE;
}
::DDS::ReturnCode_t
DDS_DomainParticipantFactory_i::set_default_participant_qos_with_profile (
const char * qos_profile)
{
char * lib_name = get_library_name(qos_profile);
char * prof_name = get_profile_name(qos_profile);
::DDS::ReturnCode_t retcode = ::DDS::RETCODE_ERROR;
if (lib_name != 0 && prof_name != 0)
{
retcode = DDSDomainParticipantFactory::get_instance ()->
set_default_participant_qos_with_profile (lib_name, prof_name);
}
ACE_OS::free (lib_name);
ACE_OS::free (prof_name);
return retcode;
}
/* Create a configuration dialog box window that belongs to Wireshark's
* main window and add the name of the current profile name to its title bar
*/
GtkWidget *
dlg_conf_window_new(const gchar *title)
{
const char *profile_name;
gchar *win_name;
GtkWidget *win;
/*
* Set window title to reflect which preferences profile we are
* working with.
*/
profile_name = get_profile_name();
win_name = g_strdup_printf("%s - Profile: %s", title, profile_name);
win = dlg_window_new(win_name);
g_free(win_name);
return win;
}
ColoringRulesDialog::ColoringRulesDialog(QWidget *parent, QString add_filter) :
QDialog(parent),
ui(new Ui::ColoringRulesDialog),
conversation_colors_(NULL)
{
ui->setupUi(this);
setWindowTitle(wsApp->windowTitleString(QStringList() << tr("Coloring Rules") << get_profile_name()));
// XXX Use recent settings instead
resize(parent->width() * 2 / 3, parent->height() * 4 / 5);
ui->coloringRulesTreeWidget->setDragEnabled(true);
ui->coloringRulesTreeWidget->viewport()->setAcceptDrops(true);
ui->coloringRulesTreeWidget->setDropIndicatorShown(true);
ui->coloringRulesTreeWidget->setDragDropMode(QAbstractItemView::InternalMove);
color_filters_clone(this);
for (int i = 0; i < ui->coloringRulesTreeWidget->columnCount(); i++) {
ui->coloringRulesTreeWidget->setItemDelegateForColumn(i, &coloring_rules_tree_delegate_);
ui->coloringRulesTreeWidget->resizeColumnToContents(i);
}
coloring_rules_tree_delegate_.setTree(ui->coloringRulesTreeWidget);
if (!add_filter.isEmpty()) {
addColoringRule(false, new_rule_name_, add_filter,
palette().color(QPalette::Text),
palette().color(QPalette::Base),
true);
}
connect(ui->coloringRulesTreeWidget, SIGNAL(itemChanged(QTreeWidgetItem*,int)),
this, SLOT(updateWidgets()));
import_button_ = ui->buttonBox->addButton(tr("Import" UTF8_HORIZONTAL_ELLIPSIS), QDialogButtonBox::ApplyRole);
import_button_->setToolTip(tr("Select a file and add its filters to the end of the list."));
export_button_ = ui->buttonBox->addButton(tr("Export" UTF8_HORIZONTAL_ELLIPSIS), QDialogButtonBox::ApplyRole);
export_button_->setToolTip(tr("Save filters in a file."));
updateWidgets();
}
void MainStatusBar::showProfileMenu(const QPoint &global_pos, Qt::MouseButton button)
{
const gchar *profile_name = get_profile_name();
bool separator_added = false;
GList *fl_entry;
profile_def *profile;
QAction *pa;
init_profile_list();
fl_entry = current_profile_list();
profile_menu_.clear();
while (fl_entry && fl_entry->data) {
profile = (profile_def *) fl_entry->data;
if (!profile->is_global || !profile_exists(profile->name, false)) {
if (profile->is_global && !separator_added) {
profile_menu_.addSeparator();
separator_added = true;
}
pa = profile_menu_.addAction(profile->name);
if (strcmp(profile->name, profile_name) == 0) {
/* Bold current profile */
QFont pa_font = pa->font();
pa_font.setBold(true);
pa->setFont(pa_font);
pa->setCheckable(true);
pa->setChecked(true);
}
connect(pa, SIGNAL(triggered()), this, SLOT(switchToProfile()));
}
fl_entry = g_list_next(fl_entry);
}
if (button == Qt::LeftButton) {
profile_menu_.exec(global_pos);
} else {
ctx_menu_.exec(global_pos);
}
}
/* reload the profile, adding read/write file specified by fn if it is not
* NULL.
*/
static int
reload_profile(virSecurityManagerPtr mgr,
virDomainDefPtr def,
const char *fn,
bool append)
{
int rc = -1;
char *profile_name = NULL;
virSecurityLabelDefPtr secdef = virDomainDefGetSecurityLabelDef(
def, SECURITY_APPARMOR_NAME);
if (!secdef)
return rc;
if (secdef->norelabel)
return 0;
if ((profile_name = get_profile_name(def)) == NULL)
return rc;
/* Update the profile only if it is loaded */
if (profile_loaded(secdef->imagelabel) >= 0) {
if (load_profile(mgr, secdef->imagelabel, def, fn, append) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot update AppArmor profile "
"\'%s\'"),
secdef->imagelabel);
goto cleanup;
}
}
rc = 0;
cleanup:
VIR_FREE(profile_name);
return rc;
}
void WiresharkApplication::setConfigurationProfile(const gchar *profile_name)
{
char *gdp_path, *dp_path;
char *rf_path;
int rf_open_errno;
gchar *err_msg = NULL;
/* First check if profile exists */
if (!profile_exists(profile_name, FALSE)) {
if (profile_exists(profile_name, TRUE)) {
char *pf_dir_path, *pf_dir_path2, *pf_filename;
/* Copy from global profile */
if (create_persconffile_profile(profile_name, &pf_dir_path) == -1) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"Can't create directory\n\"%s\":\n%s.",
pf_dir_path, g_strerror(errno));
g_free(pf_dir_path);
}
if (copy_persconffile_profile(profile_name, profile_name, TRUE, &pf_filename,
&pf_dir_path, &pf_dir_path2) == -1) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"Can't copy file \"%s\" in directory\n\"%s\" to\n\"%s\":\n%s.",
pf_filename, pf_dir_path2, pf_dir_path, g_strerror(errno));
g_free(pf_filename);
g_free(pf_dir_path);
g_free(pf_dir_path2);
}
} else {
/* No personal and no global profile exists */
return;
}
}
/* Then check if changing to another profile */
if (profile_name && strcmp (profile_name, get_profile_name()) == 0) {
return;
}
/* Get the current geometry, before writing it to disk */
emit profileChanging();
if (profile_exists(get_profile_name(), FALSE)) {
/* Write recent file for profile we are leaving, if it still exists */
write_profile_recent();
}
/* Set profile name and update the status bar */
set_profile_name (profile_name);
emit profileNameChanged(profile_name);
/* Apply new preferences */
readConfigurationFiles (&gdp_path, &dp_path, true);
if (!recent_read_profile_static(&rf_path, &rf_open_errno)) {
simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
"Could not open common recent file\n\"%s\": %s.",
rf_path, g_strerror(rf_open_errno));
g_free(rf_path);
}
if (recent.gui_fileopen_remembered_dir &&
test_for_directory(recent.gui_fileopen_remembered_dir) == EISDIR) {
set_last_open_dir(recent.gui_fileopen_remembered_dir);
}
timestamp_set_type (recent.gui_time_format);
timestamp_set_precision(recent.gui_time_precision);
timestamp_set_seconds_type (recent.gui_seconds_format);
packet_list_enable_color(recent.packet_list_colorize);
tap_update_timer_.setInterval(prefs.tap_update_interval);
prefs_to_capture_opts();
prefs_apply_all();
#ifdef HAVE_LIBPCAP
update_local_interfaces();
#endif
setMonospaceFont(prefs.gui_qt_font_name);
emit columnsChanged();
emit preferencesChanged();
emit recentFilesRead();
emit filterExpressionsChanged();
emit checkDisplayFilter();
/* Enable all protocols and disable from the disabled list */
proto_enable_all();
if (gdp_path == NULL && dp_path == NULL) {
set_disabled_protos_list();
set_disabled_heur_dissector_list();
}
/* Reload color filters */
if (!color_filters_reload(&err_msg, color_filter_add_cb)) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_msg);
g_free(err_msg);
}
emit localInterfaceListChanged();
emit packetDissectionChanged();
}
/* Attempt to Write out "recent common" to the user's recent common file.
If we got an error report it with a dialog box and return FALSE,
otherwise return TRUE. */
gboolean
write_recent(void)
{
char *pf_dir_path;
char *rf_path;
FILE *rf;
/* To do:
* - Split output lines longer than MAX_VAL_LEN
* - Create a function for the preference directory check/creation
* so that duplication can be avoided with filter.c
*/
/* Create the directory that holds personal configuration files, if
necessary. */
if (create_persconffile_dir(&pf_dir_path) == -1) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"Can't create directory\n\"%s\"\nfor recent file: %s.", pf_dir_path,
g_strerror(errno));
g_free(pf_dir_path);
return FALSE;
}
rf_path = get_persconffile_path(RECENT_COMMON_FILE_NAME, FALSE);
if ((rf = ws_fopen(rf_path, "w")) == NULL) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"Can't open recent file\n\"%s\": %s.", rf_path,
g_strerror(errno));
g_free(rf_path);
return FALSE;
}
g_free(rf_path);
fputs("# Recent settings file for Wireshark " VERSION ".\n"
"#\n"
"# This file is regenerated each time Wireshark is quit.\n"
"# So be careful, if you want to make manual changes here.\n"
"\n"
"######## Recent capture files (latest last), cannot be altered through command line ########\n"
"\n", rf);
menu_recent_file_write_all(rf);
fputs("\n"
"######## Recent capture filters (latest last), cannot be altered through command line ########\n"
"\n", rf);
cfilter_recent_write_all(rf);
fputs("\n"
"######## Recent display filters (latest last), cannot be altered through command line ########\n"
"\n", rf);
dfilter_recent_combo_write_all(rf);
#ifdef HAVE_PCAP_REMOTE
fputs("\n"
"######## Recent remote hosts, cannot be altered through command line ########\n"
"\n", rf);
capture_remote_combo_recent_write_all(rf);
#endif
fprintf(rf, "\n# Main window geometry.\n");
fprintf(rf, "# Decimal numbers.\n");
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_X ": %d\n", recent.gui_geometry_main_x);
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_Y ": %d\n", recent.gui_geometry_main_y);
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_WIDTH ": %d\n",
recent.gui_geometry_main_width);
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_HEIGHT ": %d\n",
recent.gui_geometry_main_height);
fprintf(rf, "\n# Main window maximized.\n");
fprintf(rf, "# TRUE or FALSE (case-insensitive).\n");
fprintf(rf, RECENT_GUI_GEOMETRY_MAIN_MAXIMIZED ": %s\n",
recent.gui_geometry_main_maximized == TRUE ? "TRUE" : "FALSE");
fprintf(rf, "\n# Statusbar left pane size.\n");
fprintf(rf, "# Decimal number.\n");
if (recent.gui_geometry_status_pane_left != 0) {
fprintf(rf, RECENT_GUI_GEOMETRY_STATUS_PANE_LEFT ": %d\n",
recent.gui_geometry_status_pane_left);
}
fprintf(rf, "\n# Statusbar middle pane size.\n");
fprintf(rf, "# Decimal number.\n");
if (recent.gui_geometry_status_pane_right != 0) {
fprintf(rf, RECENT_GUI_GEOMETRY_STATUS_PANE_RIGHT ": %d\n",
recent.gui_geometry_status_pane_right);
}
fprintf(rf, "\n# Last used Configuration Profile.\n");
fprintf(rf, RECENT_LAST_USED_PROFILE ": %s\n", get_profile_name());
fprintf(rf, "\n# WLAN statistics upper pane size.\n");
fprintf(rf, "# Decimal number.\n");
fprintf(rf, RECENT_GUI_GEOMETRY_WLAN_STATS_PANE ": %d\n",
recent.gui_geometry_wlan_stats_pane);
fprintf(rf, "\n# Warn if running with elevated permissions (e.g. as root).\n");
fprintf(rf, "# TRUE or FALSE (case-insensitive).\n");
fprintf(rf, RECENT_KEY_PRIVS_WARN_IF_ELEVATED ": %s\n",
recent.privs_warn_if_elevated == TRUE ? "TRUE" : "FALSE");
fprintf(rf, "\n# Warn if npf.sys isn't loaded on Windows >= 6.0.\n");
fprintf(rf, "# TRUE or FALSE (case-insensitive).\n");
fprintf(rf, RECENT_KEY_PRIVS_WARN_IF_NO_NPF ": %s\n",
recent.privs_warn_if_no_npf == TRUE ? "TRUE" : "FALSE");
window_geom_recent_write_all(rf);
fclose(rf);
/* XXX - catch I/O errors (e.g. "ran out of disk space") and return
an error indication, or maybe write to a new recent file and
rename that file on top of the old one only if there are not I/O
errors. */
return TRUE;
}
int main(int argc, char** argv)
{
int ch, profile = 0, strategy = 0, major = 1, minor = 0, revision;
GLboolean debug = GL_FALSE, forward = GL_FALSE, list = GL_FALSE;
GLint flags, mask;
GLFWwindow window;
while ((ch = getopt(argc, argv, "dfhlm:n:p:r:")) != -1)
{
switch (ch)
{
case 'd':
debug = GL_TRUE;
break;
case 'f':
forward = GL_TRUE;
break;
case 'h':
usage();
exit(EXIT_SUCCESS);
case 'l':
list = GL_TRUE;
break;
case 'm':
major = atoi(optarg);
break;
case 'n':
minor = atoi(optarg);
break;
case 'p':
if (strcasecmp(optarg, PROFILE_NAME_CORE) == 0)
profile = GLFW_OPENGL_CORE_PROFILE;
else if (strcasecmp(optarg, PROFILE_NAME_COMPAT) == 0)
profile = GLFW_OPENGL_COMPAT_PROFILE;
else if (strcasecmp(optarg, PROFILE_NAME_ES2) == 0)
profile = GLFW_OPENGL_ES2_PROFILE;
else
{
usage();
exit(EXIT_FAILURE);
}
break;
case 'r':
if (strcasecmp(optarg, STRATEGY_NAME_NONE) == 0)
strategy = GLFW_OPENGL_NO_RESET_NOTIFICATION;
else if (strcasecmp(optarg, STRATEGY_NAME_LOSE) == 0)
strategy = GLFW_OPENGL_LOSE_CONTEXT_ON_RESET;
else
{
usage();
exit(EXIT_FAILURE);
}
break;
default:
usage();
exit(EXIT_FAILURE);
}
}
argc -= optind;
argv += optind;
glfwSetErrorCallback(error_callback);
if (!glfwInit())
{
fprintf(stderr, "Failed to initialize GLFW: %s\n", glfwErrorString(glfwGetError()));
exit(EXIT_FAILURE);
}
if (major != 1 || minor != 0)
{
glfwWindowHint(GLFW_OPENGL_VERSION_MAJOR, major);
glfwWindowHint(GLFW_OPENGL_VERSION_MINOR, minor);
}
if (debug)
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
if (forward)
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
if (profile != 0)
glfwWindowHint(GLFW_OPENGL_PROFILE, profile);
if (strategy)
glfwWindowHint(GLFW_OPENGL_ROBUSTNESS, strategy);
// We assume here that we stand a better chance of success by leaving all
// possible details of pixel format selection to GLFW
window = glfwCreateWindow(0, 0, GLFW_WINDOWED, "Version", NULL);
if (!window)
exit(EXIT_FAILURE);
glfwMakeContextCurrent(window);
// Report GLFW version
glfwGetVersion(&major, &minor, &revision);
printf("GLFW header version: %u.%u.%u\n",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
printf("GLFW library version: %u.%u.%u\n", major, minor, revision);
if (major != GLFW_VERSION_MAJOR ||
minor != GLFW_VERSION_MINOR ||
revision != GLFW_VERSION_REVISION)
{
printf("*** WARNING: GLFW version mismatch! ***\n");
}
printf("GLFW library version string: \"%s\"\n", glfwGetVersionString());
// Report OpenGL version
printf("OpenGL context version string: \"%s\"\n", glGetString(GL_VERSION));
major = glfwGetWindowParam(window, GLFW_OPENGL_VERSION_MAJOR);
minor = glfwGetWindowParam(window, GLFW_OPENGL_VERSION_MINOR);
revision = glfwGetWindowParam(window, GLFW_OPENGL_REVISION);
printf("OpenGL context version parsed by GLFW: %u.%u.%u\n", major, minor, revision);
// Report OpenGL context properties
if (major >= 3)
{
glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
printf("OpenGL context flags (0x%08x):", flags);
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
printf(" forward-compatible");
if (flags & 0)
printf(" debug");
putchar('\n');
printf("OpenGL context flags parsed by GLFW:");
if (glfwGetWindowParam(window, GLFW_OPENGL_FORWARD_COMPAT))
printf(" forward-compatible");
if (glfwGetWindowParam(window, GLFW_OPENGL_DEBUG_CONTEXT))
printf(" debug");
putchar('\n');
}
if (major > 3 || (major == 3 && minor >= 2))
{
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
printf("OpenGL profile mask (0x%08x): %s\n", mask, get_profile_name(mask));
printf("OpenGL profile mask parsed by GLFW: %s\n",
get_glfw_profile_name(glfwGetWindowParam(window, GLFW_OPENGL_PROFILE)));
}
printf("OpenGL context renderer string: \"%s\"\n", glGetString(GL_RENDERER));
printf("OpenGL context vendor string: \"%s\"\n", glGetString(GL_VENDOR));
if (major > 1)
{
printf("OpenGL context shading language version: \"%s\"\n",
glGetString(GL_SHADING_LANGUAGE_VERSION));
}
// Report OpenGL extensions
if (list)
list_extensions(major, minor);
glfwTerminate();
exit(EXIT_SUCCESS);
}
::DDS::DomainParticipant_ptr
DDS_DomainParticipantFactory_i::create_participant_with_profile (
::DDS::DomainId_t domain_id,
const char * qos_profile,
::DDS::DomainParticipantListener_ptr a_listener,
::DDS::StatusMask mask)
{
DDS4CCM_TRACE ("DDS_DomainParticipantFactory_i::"
"create_participant_with_profile");
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
"DDS_DomainParticipantFactory_i::create_participant_with_profile - "
"Start creating domain participant: "
"profile <%C> - domain <%d>\n",
qos_profile, domain_id));
DDS_DomainParticipantListener_i *ccm_dds_dpl = 0;
if (! ::CORBA::is_nil (a_listener))
{
ACE_NEW_THROW_EX (ccm_dds_dpl,
DDS_DomainParticipantListener_i (a_listener),
::CORBA::NO_MEMORY ());
}
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
"DDS_DomainParticipantFactory_i::create_participant_with_profile - "
"Creating participant: profile <%C> - domain <%d>\n",
qos_profile,
domain_id));
char * lib_name = get_library_name(qos_profile);
char * prof_name = get_profile_name(qos_profile);
DDSDomainParticipant * dds_dp = 0;
if (lib_name != 0 && prof_name != 0)
{
dds_dp = DDSDomainParticipantFactory::get_instance ()->
create_participant_with_profile (domain_id,
lib_name,
prof_name,
ccm_dds_dpl,
mask);
}
ACE_OS::free (lib_name);
ACE_OS::free (prof_name);
if (!dds_dp)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_DomainParticipantFactory_i::create_participant_with_profile <%C> - "
"Error: Unable to create DomainParticipant for domain <%d>\n",
qos_profile,
domain_id));
delete ccm_dds_dpl;
return ::DDS::DomainParticipant::_nil ();
}
::DDS::DomainParticipant_var retval;
ACE_NEW_THROW_EX (retval,
DDS_DomainParticipant_i (dds_dp),
::CORBA::NO_MEMORY ());
DDS_ReturnCode_t retcode = dds_dp->enable ();
if (retcode != DDS_RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_DomainParticipantFactory_i::create_participant_with_profile <%C> - "
"Error: Unable to enable DomainParticipant for domain <%d>: <%C>\n",
qos_profile,
domain_id,
::CIAO::DDS4CCM::translate_retcode (retcode)));
delete ccm_dds_dpl;
throw ::CORBA::INTERNAL ();
}
if (ccm_dds_dpl)
{
ccm_dds_dpl->set_dds_dp (retval.in ());
}
DDS_DomainParticipant_i * typed_dp =
dynamic_cast < DDS_DomainParticipant_i *>
(retval.in ());
if (typed_dp)
{
typed_dp->set_rti_entity (dds_dp);
}
return retval._retn ();
}
static GstFlowReturn
gst_dirac_parse_handle_frame (GstBaseParse * parse,
GstBaseParseFrame * frame, gint * skipsize)
{
int off;
guint32 next_header;
GstMapInfo map;
guint8 *data;
gsize size;
gboolean have_picture = FALSE;
int offset;
guint framesize = 0;
gst_buffer_map (frame->buffer, &map, GST_MAP_READ);
data = map.data;
size = map.size;
if (G_UNLIKELY (size < 13)) {
*skipsize = 1;
goto out;
}
GST_DEBUG ("%" G_GSIZE_FORMAT ": %02x %02x %02x %02x", size, data[0], data[1],
data[2], data[3]);
if (GST_READ_UINT32_BE (data) != 0x42424344) {
GstByteReader reader;
gst_byte_reader_init (&reader, data, size);
off = gst_byte_reader_masked_scan_uint32 (&reader, 0xffffffff,
0x42424344, 0, size);
if (off < 0) {
*skipsize = size - 3;
goto out;
}
GST_LOG_OBJECT (parse, "possible sync at buffer offset %d", off);
GST_DEBUG ("skipping %d", off);
*skipsize = off;
goto out;
}
/* have sync, parse chunks */
offset = 0;
while (!have_picture) {
GST_DEBUG ("offset %d:", offset);
if (offset + 13 >= size) {
framesize = offset + 13;
goto out;
}
GST_DEBUG ("chunk type %02x", data[offset + 4]);
if (GST_READ_UINT32_BE (data + offset) != 0x42424344) {
GST_DEBUG ("bad header");
*skipsize = 3;
goto out;
}
next_header = GST_READ_UINT32_BE (data + offset + 5);
GST_DEBUG ("next_header %d", next_header);
if (next_header == 0)
next_header = 13;
if (SCHRO_PARSE_CODE_IS_PICTURE (data[offset + 4])) {
have_picture = TRUE;
}
offset += next_header;
if (offset >= size) {
framesize = offset;
goto out;
}
}
gst_buffer_unmap (frame->buffer, &map);
framesize = offset;
GST_DEBUG ("framesize %d", framesize);
g_assert (framesize <= size);
if (data[4] == SCHRO_PARSE_CODE_SEQUENCE_HEADER) {
GstCaps *caps;
GstDiracParse *diracparse = GST_DIRAC_PARSE (parse);
DiracSequenceHeader sequence_header;
int ret;
ret = dirac_sequence_header_parse (&sequence_header, data + 13, size - 13);
if (ret) {
memcpy (&diracparse->sequence_header, &sequence_header,
sizeof (sequence_header));
caps = gst_caps_new_simple ("video/x-dirac",
"width", G_TYPE_INT, sequence_header.width,
"height", G_TYPE_INT, sequence_header.height,
"framerate", GST_TYPE_FRACTION,
sequence_header.frame_rate_numerator,
sequence_header.frame_rate_denominator,
"pixel-aspect-ratio", GST_TYPE_FRACTION,
sequence_header.aspect_ratio_numerator,
sequence_header.aspect_ratio_denominator,
"interlace-mode", G_TYPE_STRING,
sequence_header.interlaced ? "interleaved" : "progressive",
"profile", G_TYPE_STRING, get_profile_name (sequence_header.profile),
"level", G_TYPE_STRING, get_level_name (sequence_header.level), NULL);
gst_pad_set_caps (GST_BASE_PARSE_SRC_PAD (parse), caps);
gst_caps_unref (caps);
gst_base_parse_set_frame_rate (parse,
sequence_header.frame_rate_numerator,
sequence_header.frame_rate_denominator, 0, 0);
}
}
gst_base_parse_set_min_frame_size (parse, 13);
return gst_base_parse_finish_frame (parse, frame, framesize);
out:
gst_buffer_unmap (frame->buffer, &map);
if (framesize)
gst_base_parse_set_min_frame_size (parse, framesize);
return GST_FLOW_OK;
}
::DDS::DataWriter_ptr
DDS_Publisher_i::create_datawriter_with_profile (::DDS::Topic_ptr a_topic,
const char* qos_profile,
::DDS::DataWriterListener_ptr a_listener,
::DDS::StatusMask mask)
{
DDS4CCM_TRACE ("DDS_Publisher_i::create_datawriter_with_profile");
DDS_Topic_i * topic = dynamic_cast < DDS_Topic_i * > (a_topic);
if (!topic)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_CAST_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_Publisher_i::create_datawriter_with_profile <%C>- "
"Error: Unable to cast provided topic to its servant.\n",
qos_profile));
return ::DDS::DataWriter::_nil ();
}
DDS_DataWriterListener_i *ccm_dds_dwl = 0;
if (! ::CORBA::is_nil (a_listener))
{
ACE_NEW_THROW_EX (ccm_dds_dwl,
DDS_DataWriterListener_i (a_listener, 0),
::CORBA::NO_MEMORY ());
}
char * lib_name = get_library_name(qos_profile);
char * prof_name = get_profile_name(qos_profile);
DDSDataWriter *ccm_dds_dw = 0;
if (lib_name != 0 && prof_name != 0)
{
ccm_dds_dw = this->rti_entity ()->create_datawriter_with_profile (
topic->get_rti_entity (),
lib_name,
prof_name,
ccm_dds_dwl,
mask);
}
ACE_OS::free (lib_name);
ACE_OS::free (prof_name);
if (!ccm_dds_dw)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
"DDS_Publisher_i::create_datawriter_with_profile <%C> - "
"Error: RTI Topic returned a nil datawriter.\n",
qos_profile));
delete ccm_dds_dwl;
return ::DDS::DataWriter::_nil ();
}
else
{
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_DEBUG, DDS4CCM_INFO
"DDS_Publisher_i::create_datawriter_with_profile - "
"Successfully created datawriter with profile <%C>.\n",
qos_profile));
}
::DDS::DataWriter_var retval =
DDS_TypeSupport_i::create_datawriter (ccm_dds_dw,
this->dp_.in (),
this);
if (ccm_dds_dwl)
{
ccm_dds_dwl->set_dds_entity (retval.in ());
}
return retval._retn ();
}
::DDS::Topic_ptr
DDS_DomainParticipant_i::create_topic_with_profile (
const char *impl_name,
const char *type_name,
const char *qos_profile,
::DDS::TopicListener_ptr a_listener,
::DDS::StatusMask mask)
{
DDS4CCM_TRACE ("DDS_DomainParticipant_i::create_topic_with_profile");
if (impl_name == 0)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_DomainParticipant_i::create_topic_with_profile <%C> - "
"Error: provided nil topic name\n",
qos_profile));
return ::DDS::Topic::_nil ();
}
if (type_name == 0)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_DomainParticipant_i::create_topic_with_profile <%C> - "
"Error: provided nil type name\n",
qos_profile));
return ::DDS::Topic::_nil ();
}
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_DEBUG, DDS4CCM_INFO
"DDS_DomainParticipant_i::create_topic_with_profile <%C> - "
"Attempting to create topic with name %C and type %C\n",
qos_profile,
impl_name, type_name));
DDS_TopicListener_i *ccm_dds_tl = 0;
if (! ::CORBA::is_nil (a_listener))
{
// Topic will be set later (using set_dds_topic)
ACE_NEW_THROW_EX (ccm_dds_tl,
DDS_TopicListener_i (::DDS::Topic::_nil (), a_listener),
::CORBA::NO_MEMORY ());
}
DDSTopic * dds_tp = 0;
char * lib_name = get_library_name(qos_profile);
char * prof_name = get_profile_name(qos_profile);
if (lib_name != 0 && prof_name != 0)
{
dds_tp = this->rti_entity ()->create_topic_with_profile (
impl_name,
type_name,
lib_name,
prof_name,
ccm_dds_tl,
mask);
}
ACE_OS::free (lib_name);
ACE_OS::free (prof_name);
if (!dds_tp)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_DDS_NIL_RETURN, (LM_ERROR, DDS4CCM_INFO
"DDS_DomainParticipant_i::create_topic_with_profile <%C> - "
"Error: RTI DDS returned a nil topic\n",
qos_profile));
delete ccm_dds_tl;
return ::DDS::Topic::_nil ();
}
::DDS::Topic_var retval;
ACE_NEW_THROW_EX (retval,
DDS_Topic_i (dds_tp, this),
::CORBA::NO_MEMORY ());
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
"DDS_DomainParticipant_i::create_topic_with_profile <%C> - "
"Successfully created topic with name %C and type %C\n",
qos_profile,
impl_name, type_name));
if (ccm_dds_tl)
{
ccm_dds_tl->set_dds_topic (retval.in ());
}
return retval._retn ();
}
::DDS::Publisher_ptr
DDS_DomainParticipant_i::create_publisher_with_profile (
const char * qos_profile,
::DDS::PublisherListener_ptr a_listener,
::DDS::StatusMask mask)
{
DDS4CCM_TRACE ("DDS_DomainParticipant_i::create_publisher_with_profile");
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION_STARTING, (LM_TRACE, DDS4CCM_INFO
"DDS_DomainParticipant_i::create_publisher_with_profile <%C> - "
"Start creating Publisher\n",
qos_profile));
DDS_PublisherListener_i *ccm_dds_pl = 0;
if (! ::CORBA::is_nil (a_listener))
{
ACE_NEW_THROW_EX (ccm_dds_pl,
DDS_PublisherListener_i (a_listener, this),
::CORBA::NO_MEMORY ());
}
char * lib_name = get_library_name(qos_profile);
char * prof_name = get_profile_name(qos_profile);
DDSPublisher * ccm_dds_pub = 0;
if (lib_name != 0 && prof_name != 0)
{
ccm_dds_pub = this->rti_entity ()->create_publisher_with_profile (
lib_name,
prof_name,
ccm_dds_pl,
mask);
}
ACE_OS::free (lib_name);
ACE_OS::free (prof_name);
if (!ccm_dds_pub)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_DomainParticipant_i::create_publisher_with_profile <%C> - "
"Error: Unable to create Publisher\n",
qos_profile));
delete ccm_dds_pl;
return ::DDS::Publisher::_nil ();
}
::DDS::Publisher_var retval;
ACE_NEW_THROW_EX (retval,
DDS_Publisher_i (ccm_dds_pub, this),
::CORBA::NO_MEMORY ());
DDS4CCM_DEBUG (DDS4CCM_LOG_LEVEL_ACTION, (LM_INFO, DDS4CCM_INFO
"DDS_DomainParticipant_i::create_publisher_with_profile <%C> - "
"Successfully created a DDSPublisher\n",
qos_profile));
DDS_ReturnCode_t retcode = ccm_dds_pub->enable ();
if (retcode != DDS_RETCODE_OK)
{
DDS4CCM_ERROR (DDS4CCM_LOG_LEVEL_ERROR, (LM_ERROR, DDS4CCM_INFO
"DDS_DomainParticipant_i"
"::create_publisher_with_profile <%C> - "
"Error: Unable to create Publisher: <%C>\n",
qos_profile,
::CIAO::DDS4CCM::translate_retcode (retcode)));
delete ccm_dds_pl;
throw ::CORBA::INTERNAL ();
}
return retval._retn ();
}
ColoringRulesDialog::ColoringRulesDialog(QWidget *parent, QString add_filter) :
GeometryStateDialog(parent),
ui(new Ui::ColoringRulesDialog),
colorRuleModel_(palette().color(QPalette::Text), palette().color(QPalette::Base), this),
colorRuleDelegate_(this)
{
ui->setupUi(this);
if (parent) loadGeometry(parent->width() * 2 / 3, parent->height() * 4 / 5);
setWindowTitle(wsApp->windowTitleString(tr("Coloring Rules %1").arg(get_profile_name())));
ui->coloringRulesTreeView->setModel(&colorRuleModel_);
ui->coloringRulesTreeView->setItemDelegate(&colorRuleDelegate_);
ui->coloringRulesTreeView->viewport()->setAcceptDrops(true);
for (int i = 0; i < colorRuleModel_.columnCount(); i++) {
ui->coloringRulesTreeView->resizeColumnToContents(i);
}
#ifdef Q_OS_MAC
ui->newToolButton->setAttribute(Qt::WA_MacSmallSize, true);
ui->deleteToolButton->setAttribute(Qt::WA_MacSmallSize, true);
ui->copyToolButton->setAttribute(Qt::WA_MacSmallSize, true);
ui->clearToolButton->setAttribute(Qt::WA_MacSmallSize, true);
ui->pathLabel->setAttribute(Qt::WA_MacSmallSize, true);
#endif
connect(ui->coloringRulesTreeView->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)),
this, SLOT(colorRuleSelectionChanged(const QItemSelection &, const QItemSelection &)));
connect(&colorRuleDelegate_, SIGNAL(invalidField(const QModelIndex&, const QString&)),
this, SLOT(invalidField(const QModelIndex&, const QString&)));
connect(&colorRuleDelegate_, SIGNAL(validField(const QModelIndex&)),
this, SLOT(validField(const QModelIndex&)));
connect(&colorRuleModel_, SIGNAL(rowsInserted(const QModelIndex &, int, int)), this, SLOT(rowCountChanged()));
connect(&colorRuleModel_, SIGNAL(rowsRemoved(const QModelIndex &, int, int)), this, SLOT(rowCountChanged()));
rowCountChanged();
import_button_ = ui->buttonBox->addButton(tr("Import" UTF8_HORIZONTAL_ELLIPSIS), QDialogButtonBox::ApplyRole);
import_button_->setToolTip(tr("Select a file and add its filters to the end of the list."));
export_button_ = ui->buttonBox->addButton(tr("Export" UTF8_HORIZONTAL_ELLIPSIS), QDialogButtonBox::ApplyRole);
export_button_->setToolTip(tr("Save filters in a file."));
QPushButton *copy_button = ui->buttonBox->addButton(tr("Copy from"), QDialogButtonBox::ActionRole);
CopyFromProfileMenu *copy_from_menu = new CopyFromProfileMenu(COLORFILTERS_FILE_NAME, copy_button);
copy_button->setMenu(copy_from_menu);
copy_button->setToolTip(tr("Copy coloring rules from another profile."));
copy_button->setEnabled(copy_from_menu->haveProfiles());
connect(copy_from_menu, SIGNAL(triggered(QAction *)), this, SLOT(copyFromProfile(QAction *)));
QString abs_path = gchar_free_to_qstring(get_persconffile_path(COLORFILTERS_FILE_NAME, TRUE));
if (file_exists(abs_path.toUtf8().constData())) {
ui->pathLabel->setText(abs_path);
ui->pathLabel->setUrl(QUrl::fromLocalFile(abs_path).toString());
ui->pathLabel->setToolTip(tr("Open ") + COLORFILTERS_FILE_NAME);
ui->pathLabel->setEnabled(true);
}
if (!add_filter.isEmpty()) {
colorRuleModel_.addColor(false, add_filter, palette().color(QPalette::Text), palette().color(QPalette::Base));
//setup the buttons appropriately
ui->coloringRulesTreeView->setCurrentIndex(colorRuleModel_.index(0, 0));
//set edit on display filter
ui->coloringRulesTreeView->edit(colorRuleModel_.index(0, 1));
}else {
ui->coloringRulesTreeView->setCurrentIndex(QModelIndex());
}
checkUnknownColorfilters();
updateHint();
}
void WiresharkApplication::setConfigurationProfile(const gchar *profile_name)
{
char *gdp_path, *dp_path;
char *rf_path;
int rf_open_errno;
/* First check if profile exists */
if (!profile_exists(profile_name, FALSE)) {
if (profile_exists(profile_name, TRUE)) {
char *pf_dir_path, *pf_dir_path2, *pf_filename;
/* Copy from global profile */
if (create_persconffile_profile(profile_name, &pf_dir_path) == -1) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"Can't create directory\n\"%s\":\n%s.",
pf_dir_path, g_strerror(errno));
g_free(pf_dir_path);
}
if (copy_persconffile_profile(profile_name, profile_name, TRUE, &pf_filename,
&pf_dir_path, &pf_dir_path2) == -1) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"Can't copy file \"%s\" in directory\n\"%s\" to\n\"%s\":\n%s.",
pf_filename, pf_dir_path2, pf_dir_path, g_strerror(errno));
g_free(pf_filename);
g_free(pf_dir_path);
g_free(pf_dir_path2);
}
} else {
/* No personal and no global profile exists */
return;
}
}
/* Then check if changing to another profile */
if (profile_name && strcmp (profile_name, get_profile_name()) == 0) {
return;
}
/* Get the current geometry, before writing it to disk */
emit profileChanging();
if (profile_exists(get_profile_name(), FALSE)) {
/* Write recent file for profile we are leaving, if it still exists */
write_profile_recent();
}
/* Set profile name and update the status bar */
set_profile_name (profile_name);
emit profileNameChanged(profile_name);
/* Reset current preferences and apply the new */
prefs_reset();
// menu_prefs_reset();
(void) readConfigurationFiles (&gdp_path, &dp_path);
recent_read_profile_static(&rf_path, &rf_open_errno);
if (rf_path != NULL && rf_open_errno != 0) {
simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
"Could not open common recent file\n\"%s\": %s.",
rf_path, g_strerror(rf_open_errno));
}
if (recent.gui_fileopen_remembered_dir &&
test_for_directory(recent.gui_fileopen_remembered_dir) == EISDIR) {
set_last_open_dir(recent.gui_fileopen_remembered_dir);
}
timestamp_set_type (recent.gui_time_format);
timestamp_set_seconds_type (recent.gui_seconds_format);
color_filters_enable(recent.packet_list_colorize);
tap_update_timer_.setInterval(prefs.tap_update_interval);
prefs_to_capture_opts();
prefs_apply_all();
emit preferencesChanged();
emit columnsChanged();
emit recentFilesRead();
emit filterExpressionsChanged();
// macros_post_update();
/* Enable all protocols and disable from the disabled list */
proto_enable_all();
if (gdp_path == NULL && dp_path == NULL) {
set_disabled_protos_list();
set_disabled_heur_dissector_list();
}
/* Reload color filters */
color_filters_reload();
// user_font_apply();
/* Update menus with new recent values */
// menu_recent_read_finished();
}
int main(int argc, char** argv)
{
int ch, profile = 0, major = 1, minor = 1, revision;
GLboolean debug = GL_FALSE, forward = GL_FALSE, list = GL_FALSE;
GLint flags, mask;
while ((ch = getopt(argc, argv, "dfhlm:n:p:")) != -1)
{
switch (ch)
{
case 'd':
debug = GL_TRUE;
break;
case 'f':
forward = GL_TRUE;
break;
case 'h':
usage();
exit(0);
case 'l':
list = GL_TRUE;
break;
case 'm':
major = atoi(optarg);
break;
case 'n':
minor = atoi(optarg);
break;
case 'p':
if (strcasecmp(optarg, "core") == 0)
profile = GLFW_OPENGL_CORE_PROFILE;
else if (strcasecmp(optarg, "compat") == 0)
profile = GLFW_OPENGL_COMPAT_PROFILE;
else
{
usage();
exit(1);
}
break;
default:
usage();
exit(1);
}
}
argc -= optind;
argv += optind;
if (!glfwInit())
{
fprintf(stderr, "Failed to initialize GLFW\n");
exit(1);
}
if (major != 1 || minor != 1)
{
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, major);
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, minor);
}
if (debug)
glfwOpenWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE);
if (forward)
glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
if (profile != 0)
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, profile);
// We assume here that we stand a better chance of success by leaving all
// possible details of pixel format selection to GLFW
if (!glfwOpenWindow(0, 0, 0, 0, 0, 0, 0, 0, GLFW_WINDOW))
{
glfwTerminate();
fprintf(stderr, "Failed to open GLFW window\n");
exit(1);
}
// Report GLFW version
glfwGetVersion(&major, &minor, &revision);
printf("GLFW header version: %u.%u.%u\n",
GLFW_VERSION_MAJOR,
GLFW_VERSION_MINOR,
GLFW_VERSION_REVISION);
printf("GLFW library version: %u.%u.%u\n", major, minor, revision);
if (major != GLFW_VERSION_MAJOR ||
minor != GLFW_VERSION_MINOR ||
revision != GLFW_VERSION_REVISION)
printf("*** WARNING: GLFW version mismatch! ***\n");
// Report OpenGL version
printf("OpenGL context version string: \"%s\"\n", glGetString(GL_VERSION));
glfwGetGLVersion(&major, &minor, &revision);
printf("OpenGL context version parsed by GLFW: %u.%u.%u\n", major, minor, revision);
// Report OpenGL context properties
if (major >= 3)
{
glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
printf("OpenGL context flags:");
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
puts(" forward-compatible");
else
puts(" none");
}
if (major > 3 || (major == 3 && minor >= 2))
{
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
printf("OpenGL profile mask: 0x%08x (%s)\n", mask, get_profile_name(mask));
}
printf("OpenGL context renderer string: \"%s\"\n", glGetString(GL_RENDERER));
printf("OpenGL context vendor string: \"%s\"\n", glGetString(GL_VENDOR));
if (major > 1)
{
printf("OpenGL context shading language version: \"%s\"\n",
glGetString(GL_SHADING_LANGUAGE_VERSION));
}
// Report OpenGL extensions
if (list)
list_extensions(major, minor);
glfwTerminate();
exit(0);
}
