char *usr_cmd(int fd, t_history *histo, t_options options)
{
struct termios set;
struct termios unset;
char *str;
char *cmd;
int rev_c;
int histo_pl;
(void)options;
if (init_termios(&set, &unset) == -1 ||
init_values(&histo_pl, &rev_c, &str, &cmd) == -1)
return (unset_termios(&unset));
show_cmd(str[0], fd, cmd, rev_c);
while (str[0] != 10 || str[1] != 0 || str[2] != 0)
{
if (read_cmd(fd, &str, &cmd, &rev_c) == -1)
return (unset_termios(&unset));
if (histo_pl < length_of_history(histo) && chk_str(str, 27, 91, 65) == 0)
if (take_cmd_from_history(++histo_pl, &rev_c, &cmd, histo) == -1)
return (unset_termios(&unset));
if (histo_pl > 0 && chk_str(str, 27, 91, 66) == 0)
if (take_cmd_from_history(--histo_pl, &rev_c, &cmd, histo) == -1)
return (unset_termios(&unset));
show_cmd(str[0], fd, cmd, rev_c);
}
return (finish_usr_cmd(cmd, str, unset));
}
/****************
* MAINFUNCTION *
****************/
int
main(void) {
struct state state;
/* Einlesen der uebergebenen Argumente */
read_env(param);
/*
* Initialisieren der Datenstruktur zum Abbilden des programminternen
* Berechnungsstatus
*/
init_values(&state);
/* Schreiben des KML-Headers */
print_header(&state);
/* Schreiben der zu verwendenden Farbkonfigurationen */
print_colorstyles(&state);
/* Plotten der einzelnen Netzelemente (Dichtedarstellung) und
* verwendeten Trajketorien (unsichtbar)
*/
plot(&state);
/* Schliessen der KML-Strukturen */
print_end(&state);
/* Reservierte Speicherbereiche wieder freigeben */
reset_state(&state);
return 0;
}
// creates a new MandelPod window
void new_mandel_window(void)
{
// get the graphics context
mandel_gc = pz_get_gc(1);
// create the main window
mandel_wid = pz_new_window (0, 21,
screen_info.cols, screen_info.rows - (HEADER_TOPLINE+1),
draw_header, handle_event);
#ifdef MANDELPOD_STATUS
// create the status window
status_wid = pz_new_window (22, 4, 12, 12, draw_idle_status, handle_event);
#endif
// get screen info
GrGetWindowInfo(mandel_wid, &wi);
// select the event types
GrSelectEvents (mandel_wid, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_KEY_DOWN | GR_EVENT_MASK_KEY_UP | GR_EVENT_MASK_TIMER);
// display the window
GrMapWindow (mandel_wid);
#ifdef MANDELPOD_STATUS
GrMapWindow (status_wid);
#endif
// create the timer for the busy status animation
mandel_timer_id = GrCreateTimer (mandel_wid, 250);
// start main app
init_values();
create_status();
draw_header();
calculate_mandel();
}
static plc_t configure_counters(const config_t conf, plc_t plc){
sequence_t seq = get_sequence_entry(CONFIG_MREG, conf);
if(seq) {
plc_t p = plc;
int i = 0;
char * val = NULL;
for(; i < seq->size; i++){
//names
p = declare_names(OP_MEMORY, &(seq->vars[i]), p);
//defaults
p = init_values(OP_MEMORY, &(seq->vars[i]), p);
//readonlies
p = configure_readonly(OP_MEMORY, &(seq->vars[i]), p);
//directions
if((val = get_param_val("COUNT", seq->vars[i].params))){
p = configure_counter_direction(p, i, val);
val = NULL;
}
}
return p;
}
return plc;
}
int main(int argc, const char *argv[])
{
init_tools();
init_values();
init_evaluator();
init_interpreter();
init_tests();
init_sexp_to_c();
// TO TRY: Add an -O3 flag to Xcode's compile. Then compile and profile, and see if it runs faster.
// run_tests();
// run_benchmarks();
if (argc > 1) {
if (streq(argv[1], "test")) {
run_tests();
} else if (streq(argv[1], "benchmark")) {
run_benchmarks();
} else {
value str = value_set_str(argv[1]);
value_import(str);
value_clear(&str);
}
} else {
run_interpreter();
}
return 0;
}
int main(int argc, char* args[])
{
//AllocConsole();
//freopen("CONOUT$", "a", stdout);
//Initialize our vertices based off of the XML file
init_values("resources/defaults.xml");
//Start our networking thread
pthread_t thread;
int rc;
rc = pthread_create(&thread, NULL, networking_listen_entry, (void*)NULL); //Create the thread
sendValues.init("2410", true, "192.168.0.1");
//Initialize our Libraries
glutInit(&argc, args);
init();
//Start the Program
main_loop();
pthread_cancel(thread);
//Wait until the networking thread exits
pthread_exit(NULL);
return 0;
}
static plc_t configure_reals(const config_t conf, plc_t plc){
sequence_t seq = get_sequence_entry(CONFIG_MVAR, conf);
if(seq) {
plc_t p = plc;
int i = 0;
for(; i < seq->size; i++){
//names
p = declare_names(OP_REAL_MEMORY, &(seq->vars[i]), plc);
//defaults
p = init_values(OP_REAL_MEMORY, &(seq->vars[i]), p);
//readonlies
p = configure_readonly(OP_REAL_MEMORY, &(seq->vars[i]), p);
}
return p;
}
return plc;
}
ADVANCED_COMPRESSOR::ADVANCED_COMPRESSOR (double peak_limit, double release_time, double cfrate,
double crate)
: rlevelsqn(ADVANCED_COMPRESSOR::NFILT),
rlevelsqe(ADVANCED_COMPRESSOR::NEFILT)
{
init_values();
set_parameter(1, peak_limit);
set_parameter(2, release_time);
set_parameter(3, cfrate);
set_parameter(4, crate);
MESSAGE_ITEM otemp;
otemp.setprecision(2);
otemp << "(audiofx_compressor) Advanced compressor enabled;";
otemp << " peak limit " << peakpercent;
otemp << " release time " << release_time;
otemp << " cfrate " << fastgaincompressionratio;
otemp << " crate " << compressionratio << ".";
ECA_LOG_MSG(ECA_LOGGER::info, otemp.to_string());
}
int main(int argc, char* argv[])
{
Registers registers;
Decoder decoder;
Reader reader;
int memory[1001];
init_values(®isters, memory);
read_lines(&reader, argv[1]);
while(registers.regs[eip] != 0)
{
char* line;
line = fetch_instruction(®isters, &reader);
parse(®isters, &decoder, line, memory);
parse_operand(®isters, &decoder, memory);
printf(" eip: %*i", 3, registers.regs[eip]);
printf(" eax: %*i", 3, registers.regs[eax]);
printf(" ebp: %*i", 3, registers.regs[ebp]);
printf(" esp: %i\n", registers.regs[esp]);
} // while ()
return 0;
} // main()
int main(int argc, char *argv[])
{
struct pollfd p[3];
struct timespec timeout;
struct device_settings settings;
struct sigaction sa;
sigset_t sigs;
short events;
if (argc < 3) {
std::cout << "Running " << argv[0] << " requires 'sixad'. Please run sixad instead" << std::endl;
return 1;
}
const char *mac = argv[1];
debug = atoi(argv[2]);
open_log("sixad-remote");
settings = init_values(mac);
settings.joystick.axis = false;
settings.joystick.sbuttons = false;
settings.joystick.accel = false;
settings.joystick.speed = false;
settings.joystick.pos = false;;
settings.led.enabled = false;
settings.rumble.enabled = false;
ufd = uinput_open(DEV_TYPE_REMOTE, mac, settings);
if (ufd->js < 0 || ufd->mk < 0) {
return 1;
} else if (ufd->js == 0 && ufd->mk == 0) {
syslog(LOG_ERR, "remote config has no joystick or input mode selected - please choose one!");
return 1;
}
int modes = 0;
if (settings.remote.numeric) modes |= REMOTE_KEYMODE_NUMBERIC;
if (settings.remote.dvd) modes |= REMOTE_KEYMODE_DVD;
if (settings.remote.directional) modes |= REMOTE_KEYMODE_DIRECTIONAL;
if (settings.remote.multimedia) modes |= REMOTE_KEYMODE_MULTIMEDIA;
sigfillset(&sigs);
// sigdelset(&sigs, SIGCHLD);
// sigdelset(&sigs, SIGPIPE);
// sigdelset(&sigs, SIGTERM);
// sigdelset(&sigs, SIGINT);
// sigdelset(&sigs, SIGHUP);
memset(&sa, 0, sizeof(sa));
sa.sa_flags = SA_NOCLDSTOP;
sa.sa_handler = sig_term;
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGINT, &sa, NULL);
sa.sa_handler = SIG_IGN;
sigaction(SIGCHLD, &sa, NULL);
sigaction(SIGPIPE, &sa, NULL);
if (debug) syslog(LOG_INFO, "Press any to activate");
p[0].fd = 0;
p[0].events = POLLIN | POLLERR | POLLHUP;
p[1].fd = 1;
p[1].events = POLLIN | POLLERR | POLLHUP;
p[2].fd = ufd->mk ? ufd->mk : ufd->js;
p[2].events = POLLIN | POLLERR | POLLHUP;
while (!io_canceled()) {
int i, idx = 3;
for (i = 0; i < idx; i++)
p[i].revents = 0;
timeout.tv_sec = 1;
timeout.tv_nsec = 0;
if (ppoll(p, idx, &timeout, &sigs) < 1)
continue;
if (p[1].revents & POLLIN) {
process_remote(settings, mac, modes);
}
events = p[0].revents | p[1].revents | p[2].revents;
if (events & (POLLERR | POLLHUP)) {
break;
}
}
if (debug) syslog(LOG_INFO, "Closing uinput...");
if (settings.joystick.enabled) {
uinput_close(ufd->js, debug);
}
if (settings.remote.enabled || settings.input.enabled) {
uinput_close(ufd->mk, debug);
}
delete ufd;
shutdown(isk, SHUT_RDWR);
shutdown(csk, SHUT_RDWR);
if (debug) syslog(LOG_INFO, "Done");
return 0;
}
int ACE_TMAIN(int argc, ACE_TCHAR* argv[])
{
timer = RTIHighResolutionClock_new();
DDS_ReturnCode_t retcode;
::DDS::DataReader * data_reader = 0;
::DDS::DataReader * dum_data_reader = 0;
HelloListener listener;
DummyListener dum_listener;
const char * type_name = 0;
int main_result = 1; /* error by default */
::DDS::Topic * receive_topic = 0;
::DDS::Topic * send_topic = 0;
::DDS::DataWriter * data_writer = 0;
::DDS::DataWriter * dum_data_writer = 0;
DummyPublisherListener * pub_listener = 0;
::DDS::Publisher * pub = 0;
try
{
ACE_Env_Value<int> id (ACE_TEXT("DDS4CCM_DEFAULT_DOMAIN_ID"), domain_id_);
domain_id_ = id;
if (parse_args (argc, argv) != 0)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Error arguments.\n")));
return 1;
}
/* Create the domain participant */
DDSDomainParticipant * participant =
DDSDomainParticipantFactory::get_instance()->
create_participant_with_profile(
domain_id_,
lib_name_,
prof_name_,
0,
DDS_STATUS_MASK_NONE);
if (!participant)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Sender : Unable to create domain participant.\n")));
goto clean_exit;
}
/* Register type before creating topic */
type_name = LatencyTestTypeSupport::get_type_name();
retcode = LatencyTestTypeSupport::register_type (participant,
type_name);
if (retcode != DDS_RETCODE_OK)
{
goto clean_exit;
}
send_topic = participant->create_topic_with_profile (
"send",
type_name,
lib_name_,
prof_name_,
0,
DDS_STATUS_MASK_NONE);
if (!send_topic)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create topic.\n")));
goto clean_exit;
}
receive_topic = participant->create_topic_with_profile (
"receive",
type_name,
lib_name_,
prof_name_,
0,
DDS_STATUS_MASK_NONE);
if (!receive_topic)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create topic.\n")));
goto clean_exit;
}
pub_listener = new DummyPublisherListener ();
pub = participant->create_publisher_with_profile (
lib_name_,
prof_name_,
0,
DDS_STATUS_MASK_NONE);
if (!pub)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create publisher.\n")));
goto clean_exit;
}
/* Create the data writer using the publisher */
data_writer = pub->create_datawriter_with_profile(
send_topic,
lib_name_,
prof_name_,
pub_listener,
DDS_OFFERED_DEADLINE_MISSED_STATUS |
DDS_OFFERED_INCOMPATIBLE_QOS_STATUS |
DDS_RELIABLE_WRITER_CACHE_CHANGED_STATUS |
DDS_RELIABLE_READER_ACTIVITY_CHANGED_STATUS |
DDS_LIVELINESS_LOST_STATUS |
DDS_PUBLICATION_MATCHED_STATUS);
if (!data_writer)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create data writer.\n")));
goto clean_exit;
}
/* Create a data reader, which will not be used, but is there for
* compatibility with DDS4CCM latency test, where there is always a
* reader and a writer per connector.
*/
if (both_read_write_)
{
dum_data_reader = participant->create_datareader_with_profile(
send_topic,
lib_name_,
prof_name_,
&dum_listener,
DDS_DATA_AVAILABLE_STATUS);
if (!dum_data_reader )
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create dummy data reader.\n")));
goto clean_exit;
}
}
data_reader = participant->create_datareader_with_profile(
receive_topic,
lib_name_,
prof_name_,
&listener,
DDS_DATA_AVAILABLE_STATUS);
if (!data_reader)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create data reader.\n")));
goto clean_exit;
}
/* Create a data writer, which will not be used, but is there for
* compatibility with DDS4CCM latency test, where there is always a
* reader and a writer per connector
*/
if (both_read_write_)
{
dum_data_writer = participant->create_datawriter_with_profile(
receive_topic,
lib_name_,
prof_name_,
0,
DDS_STATUS_MASK_NONE);
if (!dum_data_writer)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create dummy data writer.\n")));
goto clean_exit;
}
}
/* Create data sample for writing */
instance_ = LatencyTestTypeSupport::create_data ();
if (instance_ == 0)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Unable to create data sample.\n")));
goto clean_exit;
}
init_values();
test_data_writer_ = LatencyTestDataWriter::narrow (data_writer);
if (!test_data_writer_)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("LatencyTestDataWriter_narrow failed.\n")));
goto clean_exit;
}
// Sleep a couple seconds to allow discovery to happen
ACE_OS::sleep (5);
// handle writing of messages
start();
/* --- Clean Up --- */
ACE_OS::sleep (5);
main_result = 0;
clean_exit:
const char * read_write_str = 0;
if (both_read_write_)
{
read_write_str = "Used a extra dummy reader and writer per topic.";
}
else
{
read_write_str = "Used a reader for one topic and a writer for other topic.";
}
if((nr_of_runs_ -1) != datalen_idx_)
{
ACE_DEBUG ((LM_DEBUG, "SUMMARY SENDER : %u of %u runs completed.\n"
" Number of messages sent of last run (%u): %u\n"
"%C\n\n",
datalen_idx_,
nr_of_runs_,
datalen_idx_ + 1,
number_of_msg_,
read_write_str));
}
else
{
ACE_DEBUG ((LM_DEBUG, "TEST successful, number of runs (%u) of "
"%u messages.\n"
"%C\n\n",
nr_of_runs_,
number_of_msg_,
read_write_str));
}
ACE_DEBUG ((LM_DEBUG, "\tNumber of unexpected events : %u\n",
unexpected_count_));
if (participant)
{
retcode = participant->delete_contained_entities ();
if (retcode != DDS_RETCODE_OK)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Deletion failed.\n")));
main_result = 1;
}
retcode = DDSDomainParticipantFactory::get_instance()->
delete_participant (participant);
if (retcode != DDS_RETCODE_OK)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Deletion failed.\n")));
main_result = 1;
}
}
}
catch (const ::CORBA::Exception &ex)
{
ex._tao_print_exception("ERROR : Unexpected CORBA exception caught :");
main_result = 1;
}
delete [] datalen_range_;
delete [] duration_times_;
delete pub_listener;
return main_result;
}
Asset::Asset(const int plugin_type, const char *plugin_title)
: Indexable(1), ListItem<Asset>()
{
init_values();
}
ossimString ossimDms::toString(const ossimString& formatString)const
{
ossimString result="";
std::string::const_iterator stringIter;
ossimString tempFormatString = formatString;
if(formatString == ossimString(""))
{
tempFormatString = ossimDms::DEFAULT_FORMAT;
}
stringIter = tempFormatString.begin();
int i, d_s;
/* assign a default format if none is given */
init_values(theDegrees);
while(stringIter != tempFormatString.end())
{
switch(*stringIter)
{
case '-':
{
result +=(theWorking < 0.0) ? ('-') : (' ');
stringIter++;
break;
}
case 'c':
case 'C':
{
char temp;
if (theWorking < 0.0)
{
temp = (theLatFlag == true) ? ('S') : ('W');
}
else
{
temp= (theLatFlag == true) ? ('N') : ('E');
}
if(*stringIter == 'c')
{
temp = tolower(temp);
}
result += temp;
stringIter++;
break;
}
case 'd':
case 'D':
{ /* how many 'd's until not 'd' */
d_s = 1;
++stringIter;
while (*stringIter == 'd' || *stringIter == 'D')
{
++d_s;
++stringIter;
}
if (theAfterDot == true)
{ /* beyond the decimal point */
double fractionalDegrees = std::abs(theDegrees-(int)theDegrees);
i = d_s;
while (i > 0)
{
fractionalDegrees = fractionalDegrees * 10.0;
result += ossimString::toString((int)fractionalDegrees);
fractionalDegrees = fractionalDegrees - (int)fractionalDegrees;
--i;
}
theIntDegs = (int)(theDecDegs);
}
else
{
theIntDegs = static_cast<int>( std::abs(theDegrees) );
ossimString temp = ossimString::toString(theIntDegs);
ossimString prefix;
d_s -= (int)temp.length();
while(d_s > 0)
{
prefix += '0';
--d_s;
}
temp = prefix + temp;
result += temp;
}
// // fill the rest with blanks
// ossimString temp = ossimString::toString(theIntDegs);
// d_s -= temp.length();
// if(d_s>0)
// {
// if(theAfterDot)
// {
// while(d_s > 0)
// {
// temp+='0';
// --d_s;
// }
// }
// else
// {
// ossimString prefix;
// while(d_s > 0)
// {
// prefix += '0';
// --d_s;
// }
// temp = prefix + temp;
// }
// }
break;
}
case ' ':
{
result += *stringIter;
while (*stringIter == ' ')
{
result += *stringIter;
stringIter++;
}
break;
}
case '.':
{
theAfterDot = true;
result += *stringIter++;
break;
}
case 'm':
case 'M':
case 's':
case 'S':
{
if((*stringIter == 's') ||
(*stringIter == 'S'))
{
theDoingSeconds = true;
}
calc_mins_or_secs(&theDecDegs, stringIter, result);
break;
}
// This is code that I added so you can do additional
// formatting.
//
case '\'':
case '"':
{
result += *stringIter++;
break;
}
case '@':
{
result += (char)theDegreeSign;
stringIter++;
break;
}
default:
{
if(theDoingSeconds)
{
theAfterDot = true;
}
result += *stringIter++;
}
} /* end switch statement */
} /* end while loop */
return result;
}
Asset::Asset(const int plugin_type, const char *plugin_title)
: ListItem<Asset>(), GarbageObject("Asset")
{
init_values();
}
Asset::Asset(Asset &asset)
: ListItem<Asset>(), GarbageObject("Asset")
{
init_values();
*this = asset;
}
void
PrefAgent::create_ui()
{
// Create main preferences window.
XmStringLocalized mtfstring;
String string;
int decorations=MWM_DECOR_BORDER |
MWM_DECOR_RESIZEH |
MWM_DECOR_TITLE |
MWM_DECOR_MENU;
f_shell = WTopLevelShell (window_system().toplevel(), WPopup, "preferences");
window_system().register_shell(&f_shell);
string = CATGETS(Set_PrefAgent, 1, "Dtinfo: Preferences");
XtVaSetValues((Widget)f_shell,
XmNtitle, string,
XmNmwmDecorations, decorations,
NULL);
DECL (WXmForm, form, f_shell, "form");
DECLMC(WXmOptionMenu, options, form, "options");
DECLC (WXmPulldownMenu, options_menu, form, "options_menu");
mtfstring = CATGETS(Set_AgentLabel, 186, "Preferences for");
XtVaSetValues(options, XmNlabelString, (XmString)mtfstring, NULL);
ASSNM (WXmPushButton, f_ok, form, "ok");
ASSNM (WXmPushButton, f_apply, form, "apply");
ASSNM (WXmPushButton, f_reset, form, "reset");
DECLM (WXmPushButton, cancel, form, "cancel");
DECLM (WXmPushButton, help, form, "help");
mtfstring = CATGETS(Set_AgentLabel, 161, "OK");
XtVaSetValues(f_ok, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 201, "Apply");
XtVaSetValues(f_apply, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 202, "Reset");
XtVaSetValues(f_reset, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 162, "Cancel");
XtVaSetValues(cancel, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 48, "Help");
XtVaSetValues(help, XmNlabelString, (XmString)mtfstring, NULL);
SET_CALLBACK (f_ok,Activate,ok);
SET_CALLBACK (f_apply,Activate,apply);
SET_CALLBACK (f_reset,Activate,reset);
SET_CALLBACK (cancel,Activate,cancel);
help_agent().add_activate_help (help, (char*)"preferences_help");
DECLM (WXmFrame, frame, form, "frame");
DECL (WXmForm, container, frame, "container");
// Create browsing preferences.
DECLM (WXmPushButton, browse, options_menu, "browse");
DECL (WXmForm, browse_form, container, "browse_prefs");
DECLM (WXmLabel, browse_label, browse_form, "browse_label");
DECLM (WXmPushButton, get_browse_geo, browse_form, "get_browse_geo");
ASSNM (WXmTextField, f_browse_geo, browse_form, "browse_geo");
DECLM (WXmLabel, fs_label, browse_form, "fs_label");
DECL (WXmForm, fs_form, browse_form, "fs_form");
ASSNM (WXmTextField, f_fs_field, fs_form, "scale_field");
DECLM (WXmArrowButton, scale_up, fs_form, "scale_up");
DECLM (WXmArrowButton, scale_down, fs_form, "scale_down");
DECLM (WXmLabel, lock_label, browse_form, "lock_label");
ASSNM (WXmToggleButton, f_lock_toggle, browse_form, "lock_toggle");
mtfstring = CATGETS(Set_AgentLabel, 187, "Browsing");
XtVaSetValues(browse, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 190, "Browser Geometry");
XtVaSetValues(browse_label, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 270, "...");
XtVaSetValues(get_browse_geo, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 192, "Font Scale");
XtVaSetValues(fs_label, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 193, "Pin Window");
XtVaSetValues(lock_label, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 194, "File a Bug");
XtVaSetValues(f_lock_toggle, XmNlabelString, (XmString)mtfstring, NULL);
Dimension height;
ChangeData *inc, *dec;
// Assume that the fields are taller than the labels. If the user
// changes the font resources and violates this assumtion he's screwed
// and that's the way we like it.
height = f_fs_field.Height();
browse_label.Height (height);
fs_label.Height (height);
scale_up.Height (height/2);
scale_down.Height (height/2);
f_lock_toggle.LabelType (XmPIXMAP);
lock_label.Height (height);
fs_form.Manage();
browse_form.Manage();
f_top_panel = browse_form;
SET_CALLBACK_D (browse,Activate,switch_to_window,(Widget)browse_form);
SET_CALLBACK_D (get_browse_geo,Activate,get_geometry,(Widget)f_browse_geo);
SET_CALLBACK (f_browse_geo,ValueChanged,something_changed);
SET_CALLBACK (f_fs_field,ValueChanged,something_changed);
SET_CALLBACK (f_lock_toggle,ValueChanged,something_changed);
SET_CALLBACK (f_lock_toggle,ValueChanged,lock_toggle);
inc = new ChangeData(f_fs_field, scale_up, scale_down, 1, 5);
dec = new ChangeData(f_fs_field, scale_up, scale_down, -1, -2);
SET_CALLBACK_D (scale_up,Activate,change_cb,inc);
SET_CALLBACK_D (scale_up,Arm,arm_arrow,inc);
SET_CALLBACK (scale_up,Disarm,disarm_arrow);
SET_CALLBACK_D (scale_down,Activate,change_cb,dec);
SET_CALLBACK_D (scale_down,Arm,arm_arrow,dec);
SET_CALLBACK (scale_down,Disarm,disarm_arrow);
// Create map window preferences
DECLM (WXmPushButton, map, options_menu, "map");
DECLM (WXmForm, map_form, container, "map_prefs");
DECLM (WXmLabel, map_label, map_form, "map_label");
DECLM (WXmPushButton, get_map_geo, map_form, "get_map_geo");
ASSNM (WXmTextField, f_map_geo, map_form, "map_geo");
DECLM (WXmLabel, update_label, map_form, "update_label");
ASSNM (WXmToggleButton, f_update_toggle, map_form, "update_toggle");
mtfstring = CATGETS(Set_AgentLabel, 188, "Map");
XtVaSetValues(map, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 195, "Map Geometry");
XtVaSetValues(map_label, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 270, "...");
XtVaSetValues(get_map_geo, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 196, "Auto Update");
XtVaSetValues(update_label, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 194, "File a Bug");
XtVaSetValues(f_update_toggle, XmNlabelString, (XmString)mtfstring, NULL);
height = f_map_geo.Height();
map_label.Height (height);
update_label.Height (height);
SET_CALLBACK_D (get_map_geo,Activate,get_geometry,(Widget)f_map_geo);
SET_CALLBACK_D (map,Activate,switch_to_window,(Widget)map_form);
SET_CALLBACK (f_map_geo,ValueChanged,something_changed);
SET_CALLBACK (f_update_toggle,ValueChanged,something_changed);
SET_CALLBACK (f_update_toggle,ValueChanged,update_toggle);
map_form.Manage();
// Create history preferences
DECLM (WXmPushButton, history, options_menu, "history");
mtfstring = CATGETS(Set_AgentLabel, 260, "History");
XtVaSetValues(history, XmNlabelString, (XmString)mtfstring, NULL);
DECL (WXmForm, hist_form, container, "history_prefs");
DECLM (WXmLabel, nh_label, hist_form, "nh_label");
DECL (WXmForm, nh_form, hist_form, "nh_form");
ASSNM (WXmTextField, f_nh_field, nh_form, "nh_field");
DECLM (WXmArrowButton, nh_up, nh_form, "nh_up");
DECLM (WXmArrowButton, nh_down, nh_form, "nh_down");
DECLM (WXmLabel, sh_label, hist_form, "sh_label");
DECL (WXmForm, sh_form, hist_form, "sh_form");
ASSNM (WXmTextField, f_sh_field, sh_form, "sh_field");
DECLM (WXmArrowButton, sh_up, sh_form, "sh_up");
DECLM (WXmArrowButton, sh_down, sh_form, "sh_down");
mtfstring = CATGETS(Set_AgentLabel, 197, "Section History Size");
XtVaSetValues(nh_label, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 198, "Search History Size");
XtVaSetValues(sh_label, XmNlabelString, (XmString)mtfstring, NULL);
height = f_nh_field.Height();
nh_label.Height (height);
nh_up.Height (height/2);
nh_down.Height (height/2);
height = f_sh_field.Height();
sh_label.Height (height);
sh_up.Height (height/2);
sh_down.Height (height/2);
nh_form.Manage();
sh_form.Manage();
hist_form.Manage();
SET_CALLBACK_D (history,Activate,switch_to_window,(Widget)hist_form);
SET_CALLBACK (f_nh_field,ValueChanged,something_changed);
SET_CALLBACK (f_sh_field,ValueChanged,something_changed);
inc = new ChangeData (f_nh_field, nh_up, nh_down, 10, 1000);
dec = new ChangeData (f_nh_field, nh_up, nh_down, -10, 10);
SET_CALLBACK_D (nh_up,Activate,change_cb,inc);
SET_CALLBACK_D (nh_up,Arm,arm_arrow,inc);
SET_CALLBACK (nh_up,Disarm,disarm_arrow);
SET_CALLBACK_D (nh_down,Activate,change_cb,dec);
SET_CALLBACK_D (nh_down,Arm,arm_arrow,dec);
SET_CALLBACK (nh_down,Disarm,disarm_arrow);
inc = new ChangeData (f_sh_field, sh_up, sh_down, 10, 1000);
dec = new ChangeData (f_sh_field, sh_up, sh_down, -10, 10);
SET_CALLBACK_D (sh_up,Activate,change_cb,inc);
SET_CALLBACK_D (sh_up,Arm,arm_arrow,inc);
SET_CALLBACK (sh_up,Disarm,disarm_arrow);
SET_CALLBACK_D (sh_down,Activate,change_cb,dec);
SET_CALLBACK_D (sh_down,Arm,arm_arrow,dec);
SET_CALLBACK (sh_down,Disarm,disarm_arrow);
// Create Search preferences.
DECLM (WXmPushButton, search, options_menu, "search");
mtfstring = CATGETS(Set_AgentLabel, 189, "Searching");
XtVaSetValues(search, XmNlabelString, (XmString)mtfstring, NULL);
DECL (WXmForm, search_form, container, "search_prefs");
DECLM (WXmLabel, max_hits_label, search_form, "max_hits");
DECL (WXmForm, hits_form, search_form, "hits_form");
ASSNM (WXmTextField, f_max_hits_field, hits_form, "hits_field");
DECLM (WXmArrowButton, hits_up, hits_form, "hits_up");
DECLM (WXmArrowButton, hits_down, hits_form, "hits_down");
DECLM (WXmLabel, adisplay_label, search_form, "adisplay_label");
ASSNM (WXmToggleButton, f_adisplay_toggle, search_form, "adisplay_toggle");
mtfstring = CATGETS(Set_AgentLabel, 199, "Maximum Search Hits");
XtVaSetValues(max_hits_label, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 200, "Auto Display First Hit");
XtVaSetValues(adisplay_label, XmNlabelString, (XmString)mtfstring, NULL);
mtfstring = CATGETS(Set_AgentLabel, 194, "File a Bug");
XtVaSetValues(f_adisplay_toggle, XmNlabelString, (XmString)mtfstring, NULL);
height = f_max_hits_field.Height();
max_hits_label.Height (height);
hits_up.Height (height/2);
hits_down.Height (height/2);
adisplay_label.Height (height);
hits_form.Manage();
search_form.Manage();
SET_CALLBACK_D (search,Activate,switch_to_window,(Widget)search_form);
SET_CALLBACK (f_max_hits_field,ValueChanged,something_changed);
inc = new ChangeData (f_max_hits_field, hits_up, hits_down, 10, 500);
dec = new ChangeData (f_max_hits_field, hits_up, hits_down, -10, 10);
SET_CALLBACK_D (hits_up,Activate,change_cb,inc);
SET_CALLBACK_D (hits_up,Arm,arm_arrow,inc);
SET_CALLBACK (hits_up,Disarm,disarm_arrow);
SET_CALLBACK_D (hits_down,Activate,change_cb,dec);
SET_CALLBACK_D (hits_down,Arm,arm_arrow,dec);
SET_CALLBACK (hits_down,Disarm,disarm_arrow);
SET_CALLBACK (f_adisplay_toggle,ValueChanged,something_changed);
SET_CALLBACK (f_adisplay_toggle,ValueChanged,adisplay_toggle);
/* -------- node history size, search history size -------- */
options.SubMenuId (options_menu);
container.Manage();
form.DefaultButton (f_ok);
form.ShadowThickness (0);
form.Manage();
f_shell.Realize();
Dimension width;
f_shell.Get (WArgList (XmNheight, (XtArgVal) &height,
XmNwidth, &width,
NULL));
f_shell.Set (WArgList (XmNminHeight, height,
XmNmaxHeight, height,
XmNminWidth, width,
XmNmaxWidth, width,
NULL));
map_form.Unmanage();
hist_form.Unmanage();
search_form.Unmanage();
// Values get displayed when reset() is called on dialog display.
init_values();
}
asmlinkage long xcrypt(void *arg)
{
struct file_struct file_info;
struct user_args_t *user_args;
int err = 0;
init_values(&file_info);
if (arg == NULL) {
printk(KERN_ALERT"NULL arg received in syscall\n");
err = -EINVAL;
goto ERR;
}
user_args = kmalloc(sizeof(struct user_args_t), GFP_KERNEL);
if (!user_args) {
printk(KERN_ALERT"Couldn't allocate memory for user struct\n");
err = -ENOMEM;
goto ERR;
}
printk(KERN_ALERT"flag = %d and keylen = %d\n", user_args->flags, user_args->keylen);
printk(KERN_ALERT"all validations passed\n");
if (copy_from_user(user_args, arg, sizeof(struct user_args_t))) {
printk(KERN_ALERT"error in copy from user\n");
err = -EFAULT;
goto ERR_FREE;
}
err = validate_user_args(user_args);
if (err)
goto ERR_FREE;
file_info.in_file = getname(user_args->user_input_file);
if (IS_ERR(file_info.in_file)) {
printk(KERN_ALERT"error in file input getname\n");
err = PTR_ERR(file_info.in_file);
goto ERR_FREE;
}
printk(KERN_ALERT"getnamed inp file is %s\n", file_info.in_file->name);
file_info.out_file = getname(user_args->user_output_file);
if (IS_ERR(file_info.out_file)) {
printk(KERN_ALERT"error in file output getname\n");
err = PTR_ERR(file_info.out_file);
goto ERR_FREE;
}
printk(KERN_ALERT"getnamed out file is %s\n", file_info.out_file->name);
printk(KERN_ALERT"flag = %d and keylen = %d\n", user_args->flags, user_args->keylen);
err = main_enc_dec(&file_info, user_args);
if (err) {
printk(KERN_ALERT"got error from main_enc_dec\n");
goto ERR_FREE;
}
err = 0;
ERR_FREE:
kfree(user_args);
ERR:
printk(KERN_ALERT"Returning %d\n", err);
return err;
}
int main(int argc, char **argv){
assert (argc == 2);
init_values();
src_org = cvLoadImage(argv[1]);
//aloca memoria para origem "dinamica" para acontecer esta ser uma origem acumulativa!
src = cvCreateImage(cvGetSize(src_org),src_org->depth,src_org->nChannels);
cvCopy(src_org,src);
//cvNamedWindow("src-org");
//cvShowImage("src-org",src_org);
cvNamedWindow("src");
updateSrc();
cvNamedWindow("dst");
cvNamedWindow("config");
cvNamedWindow("config2");
int x = 30;
int y = 50;
int offset = 10;
cvMoveWindow("src",x,y);
cvMoveWindow("dst",x+offset+cvGetSize(src).width,y);
cvMoveWindow("config",670,y);
cvMoveWindow("config2",1000,y);
cvCreateTrackbar("gaussian","config",&gaussian_value,gaussian_max,gaussianCallBack);
cvCreateTrackbar("canny-low","config",&canny_low_value,canny_low_max,NULL);
cvCreateTrackbar("canny-high","config",&canny_high_value,canny_high_max,NULL);
cvCreateTrackbar("canny-en","config",&canny_enable,1,cannyCallBack);
cvCreateTrackbar("hough-minDist","config",&hough_minDist_value,hough_minDist_max,NULL);
cvCreateTrackbar("hough-param1","config",&hough_param1_value,hough_param1_max,NULL);
cvCreateTrackbar("hough-param2","config",&hough_param2_value,hough_param2_max,NULL);
cvCreateTrackbar("hough-minRadius","config",&hough_minRadius_value,hough_minRadius_max,NULL);
cvCreateTrackbar("hough-maxRadius","config",&hough_maxRadius_value,hough_maxRadius_max,NULL);
cvCreateTrackbar("hough-en","config",&hough_enable,1,houghCallBack);
cvCreateTrackbar("apply","config",&apply_value,1,applySrcCallBack);
cvCreateTrackbar("hue-min","config2",&hue_min_value,hue_max,NULL);
cvCreateTrackbar("hue-max","config2",&hue_max_value,hue_max,NULL);
cvCreateTrackbar("sat-min","config2",&sat_min_value,sat_max,NULL);
cvCreateTrackbar("sat-max","config2",&sat_max_value,sat_max,NULL);
cvCreateTrackbar("val-min","config2",&val_min_value,val_max,NULL);
cvCreateTrackbar("val-max","config2",&val_max_value,val_max,NULL);
// HSV color picker na janela SRC
cvSetMouseCallback("src",mouseCallBack,(void*)src);
// loop central... ESQ finaliza!
while(true){
if(cvWaitKey(10) == 27) break;
}
cvDestroyWindow("src");
//cvDestroyWindow("src-org");
cvDestroyWindow("dst");
cvDestroyWindow("config");
cvDestroyWindow("config2");
cvReleaseImage(&src_org);
cvReleaseImage(&src);
cvReleaseImage(&dst);
}
/*----------------------------------------------------------*/
int main(int argc, char *argv[])
{
xc_values_type xc;
xc_lda_type lda_func;
xc_gga_type gga_func;
xc_hyb_gga_type hyb_gga_func;
const xc_func_info_type *info;
FLOAT *pv2rho = NULL;
if(argc != 8){
printf("Usage:\n%s funct pol rhoa rhob sigmaaa sigmaab sigmabb\n", argv[0]);
return 1;
}
init_values(&xc, argv);
if(xc.nspin == 1){
xc.rho[0] += xc.rho[1];
xc.sigma[0] += 2.0*xc.sigma[1] + xc.sigma[2];
}
info = NULL;
switch(xc_family_from_id(xc.functional))
{
case XC_FAMILY_LDA:
if(xc.functional == XC_LDA_X)
xc_lda_x_init(&lda_func, xc.nspin, 3, 0);
else
xc_lda_init(&lda_func, xc.functional, xc.nspin);
info = lda_func.info;
break;
case XC_FAMILY_GGA:
xc_gga_init(&gga_func, xc.functional, xc.nspin);
info = gga_func.info;
break;
case XC_FAMILY_HYB_GGA:
xc_hyb_gga_init(&hyb_gga_func, xc.functional, xc.nspin);
info = hyb_gga_func.info;
break;
default:
fprintf(stderr, "Functional '%d' not found\n", xc.functional);
exit(1);
}
if(info->provides & XC_PROVIDES_FXC){
pv2rho = xc.v2rho;
}
switch(xc_family_from_id(xc.functional))
{
case XC_FAMILY_LDA:
xc_lda(&lda_func, xc.rho, &xc.zk, xc.vrho, pv2rho, NULL);
break;
case XC_FAMILY_GGA:
xc_gga(&gga_func, xc.rho, xc.sigma, &xc.zk,
xc.vrho, xc.vsigma, pv2rho, xc.v2rhosigma, xc.v2sigma);
xc_gga_end(&gga_func);
break;
case XC_FAMILY_HYB_GGA:
xc_hyb_gga(&hyb_gga_func, xc.rho, xc.sigma, &xc.zk, xc.vrho, xc.vsigma);
xc_hyb_gga_end(&hyb_gga_func);
break;
}
if(xc.nspin == 1){
xc.vrho[1] = xc.vrho[0];
xc.zk *= xc.rho[0] ;
}else{
xc.zk *= (xc.rho[0] + xc.rho[1]);
}
print_values(&xc);
return 0;
}
Circuit_Handler::Circuit_Handler(){
init_values();
}
Asset::Asset()
: ListItem<Asset>(), GarbageObject("Asset")
{
init_values();
}
Impedance::Impedance(){
init_values();
}
Asset::Asset(const char *path)
: ListItem<Asset>(), GarbageObject("Asset")
{
init_values();
strcpy(this->path, path);
}
Asset::Asset()
: Indexable(1), ListItem<Asset>()
{
init_values();
}
int main(int argc, char **argv)
{
int i, fd, nr;
unsigned char buf[128];
struct uinput_fd *ufd;
struct device_settings settings;
if (argc < 2) {
std::cout << "Usage: " << argv[0] << " /dev/hidrawX" << std::endl;
return 1;
}
if ((fd = open(argv[1], O_RDONLY)) < 0) {
std::cerr << "sixad-raw::open(hidrawX) - failed to open hidraw device" << std::endl;
return 1;
}
if ((nr=read(fd, buf, sizeof(buf))) < 0) {
std::cerr << "sixad-raw::read(fd) - failed to read from device" << std::endl;
return 1;
}
if (nr < 49 || nr > 50) {
std::cerr << "sixad-raw::read(fd) - not a sixaxis (nr = " << nr << ")" << std::endl;
return 1;
}
open_log("sixad-raw");
settings = init_values("hidraw");
// hidraw has no rumble/led support
settings.remote.enabled = false;
settings.led.enabled = false;
settings.rumble.enabled = false;
ufd = uinput_open(DEV_TYPE_SIXAXIS, "hidraw", settings);
if (ufd->js < 0 || ufd->mk < 0) {
return 1;
} else if (ufd->js == 0 && ufd->mk == 0) {
syslog(LOG_ERR, "sixaxis config has no joystick or input mode selected - please choose one!");
return 1;
}
bool msg = true;
while (true) {
nr=read(fd, buf, sizeof(buf));
if (nr < 49 || nr > 50) {
std::cerr << "sixad-raw::read(fd, buf) - failed to read from device" << std::endl;
break;
} else if (nr == 49) {
for (i=50; i>0; i--) {
buf[i] = buf[i-1];
}
}
if (msg) {
syslog(LOG_INFO, "Connected 'PLAYSTATION(R)3 Controller (hidraw)' [Battery %02X]", buf[31]);
if (nr == 49) syslog(LOG_INFO, "Notice: non-standard Sixaxis buffer size (49)");
msg = false;
}
if (settings.joystick.enabled) do_joystick(ufd->js, buf, settings.joystick);
if (settings.input.enabled) do_input(ufd->mk, buf, settings.input);
}
if (settings.joystick.enabled) {
uinput_close(ufd->js, 0);
}
if (settings.input.enabled) {
uinput_close(ufd->mk, 0);
}
std::cerr << "sixad-raw::read(buf) - connection has been broken" << std::endl;
delete ufd;
return 0;
}
Asset::Asset(Asset &asset)
: Indexable(1), ListItem<Asset>()
{
init_values();
this->copy_from(&asset, 1);
}
ossimString ossimDms::degree_to_string(double degrees,
char format[],
bool lat_flag)const
{
char cdegrees[64];
char str_fmt[10];
char *rptr, *fptr, *sptr;
int i, d_s;
/* assign a default format if none is given */
if (format[0] == '\0')
{
set_default(format, cdegrees);
}
else
{
memset(cdegrees, ' ', 64);
// strcpy(cdegrees, SPACES);
}
init_values(degrees);
rptr = cdegrees;
fptr = format;
sptr = str_fmt;
/* cycle through characters of the format and plug in values */
while (*fptr != '\0') {
switch (*fptr) {
case '-': {
(theWorking < 0.0) ? (*rptr = '-') : (*rptr = ' ');
rptr++, fptr++;
break;
}
case 'c':
case 'C': {
if (theWorking < 0.0)
(lat_flag == true) ? (*rptr = 'S') : (*rptr = 'W');
else
(lat_flag == true) ? (*rptr = 'N') : (*rptr = 'E');
rptr++, fptr++;
break;
}
case 'd':
case 'D': { /* how many 'd's until not 'd' */
d_s = 1, fptr++;
while (*fptr == 'd') {
d_s++, fptr++;
}
setup_printf(d_s, sptr); /* printf's fmt will be %x.xd */
if (theAfterDot == true) { /* beyond the decimal point */
i = d_s;
while (i-- > 0)
theDecDegs = theDecDegs * 10.0;
// theIntDegs = (int)(theDecDegs + 0.5);
theIntDegs = (int)(theDecDegs);
}
sprintf(rptr, str_fmt, theIntDegs);
if (*rptr == '0' && !theAfterDot) /* remove leading zero */
*rptr = ' ';
rptr += d_s;
break;
}
case ' ': { /* compress multiple spaces in format */
*rptr = *fptr;
while (*fptr == ' ')
fptr++;
rptr++;
break;
}
case '.': {
if (theAfterDot == true) { /* a second decimal point? */
set_default(format, cdegrees);
fptr = format;
rptr = cdegrees;
init_values(degrees);
}
else {
*rptr = *fptr;
rptr++, fptr++;
theAfterDot = true;
}
break;
}
case 'm':
case 'M':
case 's':
case 'S':
{
i = calc_mins_or_secs(&theDecDegs, fptr, rptr);
fptr += i, rptr += i; /* i == num to advance format */
break;
}
// This is code that I added so you can do additional
// formatting.
//
case '\'':
case '"':
{
*rptr = *fptr;
rptr++;
fptr++;
break;
}
case '@':
{
*rptr = (char)theDegreeSign;
rptr++;
fptr++;
break;
}
default: {
set_default(format, cdegrees);
fptr = format;
rptr = cdegrees;
init_values(degrees);
}
} /* end switch statement */
} /* end while loop */
*rptr = '\0';
return(cdegrees);
}
Asset::Asset(const char *path)
: Indexable(1), ListItem<Asset>()
{
init_values();
strcpy(this->path, path);
}
