/*****************************************************************************
* Initialization
*****************************************************************************/
AssignHotKey::AssignHotKey(QWidget* parent, const QKeySequence& keySequence)
: QDialog(parent)
{
setupUi(this);
#if defined(__APPLE__) || defined(WIN32)
QString shift(QKeySequence(Qt::Key_Shift).toString(QKeySequence::NativeText));
QString alt(QKeySequence(Qt::Key_Alt).toString(QKeySequence::NativeText));
QString meta(QKeySequence(Qt::Key_Meta).toString(QKeySequence::NativeText));
#else
QString shift("Shift");
QString alt("Alt");
QString meta("Meta");
#endif
QString str("<HTML><HEAD><TITLE></TITLE></HEAD><BODY><CENTER>");
str += QString("<H1>") + tr("Assign Key") + QString("</H1>");
str += tr("Hit the key combination that you wish to assign. "
"You may hit either a single key or a combination "
"using %1, %2, and %3.").arg(shift).arg(alt).arg(meta);
str += QString("</CENTER></BODY></HTML>");
m_infoText->setText(str);
m_infoText->setFocusPolicy(Qt::NoFocus);
m_buttonBox->setFocusPolicy(Qt::NoFocus);
m_previewEdit->setReadOnly(true);
m_previewEdit->setAlignment(Qt::AlignCenter);
m_keySequence = QKeySequence(keySequence);
m_previewEdit->setText(m_keySequence.toString(QKeySequence::NativeText));
QSettings settings;
m_autoCloseCheckBox->setChecked(settings.value(SETTINGS_AUTOCLOSE).toBool());
}
TEST_F(BuildFromXmlUnionAlign, align1_basic) {
parseMeta(
"<metalib tagsetversion='1' name='net' version='10'>"
" <union name='S1' version='1' id='33'>"
" <entry name='b1' type='int8'/>"
" <entry name='b2' type='int16'/>"
" </union>"
" <struct name='S2' version='1' id='34'>"
" <entry name='a1' type='int8'/>"
" <entry name='m_u' type='S1'/>"
" </struct>"
"</metalib>"
);
ASSERT_TRUE(t_em_no_error());
EXPECT_EQ(1, dr_meta_align(meta("S1")));
EXPECT_EQ((size_t)2, dr_meta_size(meta("S1")));
EXPECT_EQ(0, entry("S1", "b1")->m_data_start_pos);
EXPECT_EQ(0, entry("S1", "b2")->m_data_start_pos);
EXPECT_EQ(1, dr_meta_align(meta("S2")));
EXPECT_EQ((size_t)3, dr_meta_size(meta("S2")));
EXPECT_EQ(0, entry("S2", "a1")->m_data_start_pos);
EXPECT_EQ(1, entry("S2", "m_u")->m_data_start_pos);
}
// [[Rcpp::export]]
Rcpp::StringVector vcf_meta(std::string x, Rcpp::NumericVector stats) {
// Read in the meta lines.
// stats consists of elements ("meta", "header", "variants", "columns");
Rcpp::StringVector meta(stats[0]);
std::string line; // String for reading file into
std::ifstream myfile;
myfile.open (x.c_str(), std::ios::in);
if (!myfile.is_open()){
Rcpp::Rcout << "Unable to open file";
}
// Loop over the file.
int i = 0;
while ( i < stats[0] ){
Rcpp::checkUserInterrupt();
// Rcout << i << "\n";
getline (myfile,line);
meta(i) = line;
i++;
if( i % nreport == 0){
Rcpp::Rcout << "\rProcessed meta line: " << i;
}
}
myfile.close();
Rcpp::Rcout << "\rProcessed meta line: " << i;
Rcpp::Rcout << "\nMeta lines processed.\n";
return meta;
}
getmenu ()
{
if (! menu[0].len)
initmenu ();
getboxes ();
VMPutString (LINES-1, 0, "\0011\16 \17 2\16 \17 3\16 \17 4\16 \17 5\16 \17 6\16 \17 7\16 \17 8\16 \17 9\16 \01710\16Quit \17\2");
for (;;) {
drawhead (nmenu);
for (;;) {
drawmenu (&menu[nmenu]);
hidecursor ();
VSync ();
switch (KeyGet ()) {
default:
VBeep ();
continue;
case cntrl (']'): /* redraw screen */
VRedraw ();
continue;
case cntrl ('M'):
clrmenu (&menu[nmenu]);
return (1);
case cntrl ('J'):
clrmenu (&menu[nmenu]);
return (2);
case cntrl ('C'):
case cntrl ('['):
case meta ('J'): /* f0 */
clrmenu (&menu[nmenu]);
return (0);
case meta ('r'): /* right */
clrmenu (&menu[nmenu]);
if (! menu[++nmenu].mname)
nmenu = 0;
break;
case meta ('l'): /* left */
clrmenu (&menu[nmenu]);
if (--nmenu < 0) {
for (nmenu=0; menu[nmenu].mname; ++nmenu);
--nmenu;
}
break;
case meta ('u'): /* up */
upmenu (&menu[nmenu]);
continue;
case meta ('d'): /* down */
downmenu (&menu[nmenu]);
continue;
}
break;
}
}
}
void queue::check_timeouts()
{
struct timeval tv;
gettimeofday(&tv, NULL);
// check no more then once in 1 second
//TODO: make timeout check interval configurable
if ((tv.tv_sec - m_last_timeout_check_time) < 1) {
return;
}
m_last_timeout_check_time = tv.tv_sec;
LOG_INFO("checking timeouts: %ld waiting chunks", m_wait_ack.size());
auto i = m_wait_ack.begin();
while (i != m_wait_ack.end()) {
int chunk_id = i->first;
auto chunk = i->second;
if (chunk->get_time() > tv.tv_sec) {
++i;
continue;
}
// Time passed but chunk still is not complete
// so we must replay unacked items from it.
LOG_ERROR("chunk %d timed out, returning back to the popping line, current time: %ld, chunk expiration time: %f",
chunk_id, tv.tv_sec, chunk->get_time());
// There are two cases when chunk can still be in m_chunks
// while experiencing a timeout:
// 1) if it's a single chunk in the queue (and serves both
// as a push and a pop/ack target)
// 2) if iteration of this chunk was preempted by other timed out chunk
// and then later this chunk timed out in its turn
// Timeout requires switch chunk's iteration into the replay mode.
auto inserted = m_chunks.insert({chunk_id, chunk});
if (!inserted.second) {
LOG_INFO("chunk %d is already in popping line", chunk_id);
} else {
LOG_INFO("chunk %d inserted back to the popping line anew", chunk_id);
}
chunk->reset_iteration();
auto hold = i;
++i;
m_wait_ack.erase(hold);
// number of popped but still unacked entries
m_statistics.timeout_count += (chunk->meta().low_mark() - chunk->meta().acked());
}
}
void Downloader::notify_local_meta(const Meta::PathRevision& revision, const bitfield_type& bitfield) {
log_->trace() << log_tag() << BOOST_CURRENT_FUNCTION;
auto smeta = exchange_group_.fs_dir()->get_meta(revision);
for(size_t chunk_idx = 0; chunk_idx < smeta.meta().chunks().size(); chunk_idx++) {
if(bitfield[chunk_idx]) {
// We have have block, remove from needed
notify_local_chunk(smeta.meta().chunks().at(chunk_idx).ct_hash);
} else {
// We haven't this block, we need to download it
add_needed_chunk(smeta.meta().chunks().at(chunk_idx).ct_hash);
}
}
}
void docmdreg (int c) {
switch (c) {
case meta ('h'): /* home */
cmd.homecmd();
return;
case meta ('e'): /* end */
cmd.endcmd();
return;
case meta ('l'): /* left */
cmd.leftcmd();
return;
case meta ('r'): /* right */
cmd.rightcmd();
return;
case meta ('u'): /* up */
cmd.upcmd();
return;
case meta ('d'): /* down */
cmd.downcmd();
return;
case meta ('n'): /* next page */
cmd.nextcmd();
return;
case meta ('p'): /* prev page */
cmd.prevcmd();
return;
}
}
int
main()
{
CELL file_cpy = {0};
WINDOW *mainwin;
mainwin = initscr();
start_color();
setup_colors();
cbreak();
noecho();
keypad(mainwin, TRUE);
meta(mainwin, TRUE);
raw();
leaveok(mainwin, TRUE);
wbkgd(mainwin, COLOR_PAIR(COLOR_MAIN));
wattron(mainwin, COLOR_PAIR(COLOR_MAIN));
werase(mainwin);
refresh();
file_cpy.window = mainwin;
main_dir(&file_cpy);
wbkgd(mainwin, A_NORMAL);
werase(mainwin);
echo();
nocbreak();
noraw();
refresh();
endwin();
return TRUE;
}
SearchXmlHandler(MusicBrainzDownloader& dlg) : SimpleSaxHandler<SearchXmlHandler>("metadata"), m_dlg(dlg)
{
Node& meta (getRoot()); meta.onStart = &SearchXmlHandler::onMetaStart;
Node& relList (makeNode(meta, "release-list"));
Node& rel (makeNode(relList, "release")); rel.onStart = &SearchXmlHandler::onRelStart;
Node& trackList (makeNode(rel, "track-list")); trackList.onStart = &SearchXmlHandler::onTrackListStart;
}
static el_status_t emacs(int c)
{
el_status_t s;
el_keymap_t *kp;
/* Save point before interpreting input character 'c'. */
old_point = rl_point;
if (rl_meta_chars && ISMETA(c)) {
tty_push(UNMETA(c));
return meta();
}
for (kp = Map; kp->Function; kp++) {
if (kp->Key == c)
break;
}
if (kp->Function) {
s = kp->Function();
if (s == CSdispatch) /* If Function is inhibited. */
s = insert_char(c);
} else {
s = insert_char(c);
}
if (!el_pushed) {
/* No pushback means no repeat count; hacky, but true. */
Repeat = NO_ARG;
}
return s;
}
int con_init()
{
initscr();
start_color();
qiflush();
cbreak();
if ( !getenv("UNICON_NO_RAW") )
{
/* To allow curses app to handle properly ctrl+z, ctrl+c, etc.
I should not call raw() here, anyway it is known that this
will cause misinterpretation of some keys (arrows) after
resuming (SUSP -- ctrl+z)...
So, unless UNICON_NO_RAW exported and set to any value raw()
is called as usual.
*/
raw();
}
noecho();
nonl(); // `return' translation off
if (!has_colors())
fprintf(stderr,"Attention: A color terminal may be required to run this application !\n");
conio_scr=newwin(0,0,0,0);
keypad(conio_scr,TRUE); // allow function keys (keypad)
meta(conio_scr,TRUE); // switch to 8 bit terminal return values
// intrflush(conio_scr,FALSE); //
idlok(conio_scr,TRUE); // hardware line ins/del (required?)
idcok(conio_scr,TRUE); // hardware char ins/del (required?)
scrollok(conio_scr,TRUE); // scroll screen if required (cursor at bottom)
/* Color initialization */
for ( __bg=0; __bg<8; __bg++ )
for ( __fg=0; __fg<8; __fg++ )
init_pair( CON_PAIR(__fg,__bg), colortab(__fg), colortab(__bg));
con_ta(7);
return 0;
}
operator MusicSequence()
{
if( utils::LibWide().isLogOn() )
clog << "=== Parsing SMDL ===\n";
//Set our iterator
m_itread = m_itbeg;//m_src.begin();
//#FIXME: It might have been easier to just check for trk chunks and stop when none are left? We'd save a lot of iteration!!
m_itEoC = DSE::FindNextChunk( m_itbeg, m_itend, DSE::eDSEChunks::eoc ); //Our end is either the eoc chunk, or the vector's end
//Get the headers
ParseHeader();
ParseSong();
DSE::DSE_MetaDataSMDL meta( MakeMeta() );
//Check version
if( m_hdr.version == static_cast<uint16_t>(eDSEVersion::V415) )
{
//Parse tracks and return
return std::move( MusicSequence( ParseAllTracks(), std::move(meta) ) );
}
else if( m_hdr.version == static_cast<uint16_t>(eDSEVersion::V402) )
{
//Parse tracks and return
return std::move( MusicSequence( ParseAllTracks(), std::move(meta) ) );
}
else
{
#ifdef _DEBUG
cerr << "SMDL_Parser::operator MusicSequence() : Unsupported DSE version!!";
assert(false);
#endif
throw runtime_error( "SMDL_Parser::operator MusicSequence() : Unsupported DSE version!!" );
}
}
void init_ncurses_ui(double graph_limit_in, double hz_in, char use_colors_in)
{
graph_limit = graph_limit_in;
hz = hz_in;
use_colors = use_colors_in;
initscr();
start_color();
keypad(stdscr, TRUE);
intrflush(stdscr, FALSE);
noecho();
refresh();
nodelay(stdscr, FALSE);
meta(stdscr, TRUE); /* enable 8-bit input */
idlok(stdscr, TRUE); /* may give a little clunky screenredraw */
idcok(stdscr, TRUE); /* may give a little clunky screenredraw */
leaveok(stdscr, FALSE);
init_pair(C_WHITE, COLOR_WHITE, COLOR_BLACK);
init_pair(C_CYAN, COLOR_CYAN, COLOR_BLACK);
init_pair(C_MAGENTA, COLOR_MAGENTA, COLOR_BLACK);
init_pair(C_BLUE, COLOR_BLUE, COLOR_BLACK);
init_pair(C_YELLOW, COLOR_YELLOW, COLOR_BLACK);
init_pair(C_GREEN, COLOR_GREEN, COLOR_BLACK);
init_pair(C_RED, COLOR_RED, COLOR_BLACK);
kalman_init(0.0);
recreate_terminal();
}
void EMFRecordEditorFrame::OnPrint( wxCommandEvent& event )
{
wxPrintDialogData printDialogData;
wxPrinter printer(&printDialogData);
wxDC *pDC = printer.PrintDialog(this);
if (pDC && pDC->IsOk())
{
m_preview->ReleaseEMF();
// update temp file
if (Save(m_tempFile.GetFullPath()))
{
wxMetafile meta(m_tempFile.GetFullPath());
if (meta.IsOk())
{
pDC->StartDoc(m_file.GetName());
pDC->StartPage();
meta.Play(pDC);
pDC->EndPage();
pDC->EndDoc();
}
}
// make the preview get an handle to the temp EMF again
UpdatePreview();
}
}
extern "C" void chk_free(void* ptr) {
// log_message("%s: %s\n", __FILE__, __FUNCTION__);
if (!ptr) /* ignore free(NULL) */
return;
hdr_t* hdr = meta(ptr);
if (del(hdr) < 0) {
uintptr_t bt[MAX_BACKTRACE_DEPTH];
int depth = get_backtrace(bt, MAX_BACKTRACE_DEPTH);
if (hdr->tag == BACKLOG_TAG) {
log_message("+++ ALLOCATION %p SIZE %d BYTES MULTIPLY FREED!\n",
user(hdr), hdr->size);
log_message("+++ ALLOCATION %p SIZE %d ALLOCATED HERE:\n",
user(hdr), hdr->size);
log_backtrace(hdr->bt, hdr->bt_depth);
/* hdr->freed_bt_depth should be nonzero here */
log_message("+++ ALLOCATION %p SIZE %d FIRST FREED HERE:\n",
user(hdr), hdr->size);
log_backtrace(hdr->freed_bt, hdr->freed_bt_depth);
log_message("+++ ALLOCATION %p SIZE %d NOW BEING FREED HERE:\n",
user(hdr), hdr->size);
log_backtrace(bt, depth);
} else {
log_message("+++ ALLOCATION %p IS CORRUPTED OR NOT ALLOCATED VIA TRACKER!\n",
user(hdr));
log_backtrace(bt, depth);
}
} else {
hdr->freed_bt_depth = get_backtrace(hdr->freed_bt, MAX_BACKTRACE_DEPTH);
add_to_backlog(hdr);
}
}
static void initconio(void)
{
int x, y;
initialized = 1;
initscr();
start_color();
nonl();
raw();
noecho();
win = newwin(0,0,0,0);
keypad(win,TRUE);
meta(win,TRUE);
idlok(win,TRUE);
scrollok(win,TRUE);
getmaxyx(win, height, width);
/* Color initialization */
for (x = 0; x < 8; x++) {
for (y = 0; y < 8; y++) {
init_pair((y<<3)+x, x, y);
}
}
settextcolor(WHITE, BLACK);
}
// loc: path in which that port is, must not end on '/'
// port: only for printing issues
bool port_checker::port_is_enabled(const char* loc, const char* port,
const char* metadata)
{
Port::MetaContainer meta(metadata);
const char* enable_port_rel = meta["enabled by"];
bool rval = true;
if(enable_port_rel)
{
std::string enable_port = "/";
enable_port += loc;
enable_port += enable_port_rel;
const char* collapsed_loc = Ports::collapsePath(&enable_port[0]);
send_msg(collapsed_loc, 0, nullptr);
std::vector<rtosc_arg_val_t> args;
std::vector<char> strbuf;
if(sender.wait_for_reply(&strbuf, &args, collapsed_loc)) {
if(args.size() == 1 &&
(args[0].type == 'T' || args[0].type == 'F')) {
rval = (args[0].type == 'T');
}
else
m_issues.emplace(issue::enabled_port_bad_reply,
"/" + std::string(loc) + port);
} else
m_issues.emplace(issue::enabled_port_not_replied,
"/" + std::string(loc) + port);
}
return rval;
}
static int curses_init( ) {
if (videomode.curses) return 0;
// isterm?
initscr( );
if (!has_colors( )) {
endwin( );
fprintf (stderr, "Your terminal has no color support.\n");
return 1;
}
start_color( );
clear( );
curs_set( 0 );
refresh( );
leaveok(stdscr, TRUE);
preparecolor( );
cbreak( );
noecho( );
nodelay(stdscr, TRUE);
meta(stdscr, TRUE);
keypad(stdscr, TRUE);
mousemask(BUTTON1_PRESSED | BUTTON1_RELEASED | REPORT_MOUSE_POSITION | BUTTON_SHIFT | BUTTON_CTRL, NULL);
mouseinterval(0); //do no click processing, thank you
videomode.curses = 1;
getmaxyx(stdscr, Term.height, Term.width);
return 1;
}
void FilteredImage::setSource(const QString &source)
{
if(m_source != source)
{
m_source = source;
QImageReader ir(m_source);
QByteArray format(ir.format());
m_image = ir.read();
NemoImageMetadata meta(m_source, format);
if (meta.orientation() != NemoImageMetadata::TopLeft)
{
m_image = rotate(m_image, meta.orientation());
}
setImplicitWidth((qreal)m_image.width());
setImplicitHeight((qreal)m_image.height());
m_imageChanged = true;
emit sourceChanged(m_source);
emit imageChanged(m_image);
}
}
void
display_bits_box (void)
{
Dlg_head *dbits_dlg;
new_display_codepage = display_codepage;
application_keypad_mode ();
dbits_dlg = init_disp_bits_box ();
run_dlg (dbits_dlg);
if (dbits_dlg->ret_value == B_ENTER) {
const char *errmsg;
display_codepage = new_display_codepage;
errmsg =
init_translation_table (source_codepage, display_codepage);
if (errmsg)
message (1, MSG_ERROR, "%s", errmsg);
#ifndef HAVE_SLANG
meta (stdscr, display_codepage != 0);
#else
SLsmg_Display_Eight_Bit = (display_codepage != 0
&& display_codepage != 1) ? 128 : 160;
#endif
use_8th_bit_as_meta = !(inpcheck->state & C_BOOL);
}
destroy_dlg (dbits_dlg);
repaint_screen ();
}
void TLearnContext::OutputMeta() {
if (Files.MetaFile.empty()) {
return;
}
TOFStream meta(Files.MetaFile);
meta << "name\t" << OutputOptions.GetName() << Endl;
meta << "iterCount\t" << Params.BoostingOptions->IterationCount << Endl;
//output log files path relative to trainDirectory
meta << "learnErrorLog\t" << FilePathForMeta(OutputOptions.GetLearnErrorFilename(), Files.NamesPrefix) << Endl;
if (!Files.TestErrorLogFile.empty()) {
meta << "testErrorLog\t" << FilePathForMeta(OutputOptions.GetTestErrorFilename(), Files.NamesPrefix) << Endl;
}
meta << "timeLeft\t" << FilePathForMeta(OutputOptions.GetTimeLeftLogFilename(), Files.NamesPrefix) << Endl;
auto losses = CreateMetrics(
Params.LossFunctionDescription,
Params.MetricOptions,
EvalMetricDescriptor,
LearnProgress.ApproxDimension
);
for (const auto& loss : losses) {
EMetricBestValue bestValueType;
float bestValue;
loss->GetBestValue(&bestValueType, &bestValue);
TString bestValueString;
if (bestValueType == EMetricBestValue::Max) {
bestValueString = "max";
} else {
bestValueString = "min";
}
meta << "loss\t" << loss->GetDescription() << "\t" << bestValueString << Endl;
}
}
int main(void)
{
int m, i;
scanf("%d", &m);
while (m-- > 0) {
scanf("%d", &n);
printf(
"program sort(input,output);\n"
"var\n"
"a"
);
for (i = 1; i < n; i++)
printf(",%c", 'a'+i);
printf(
" : integer;\n"
"begin\n"
" readln(a"
);
for (i = 1; i < n; i++)
printf(",%c", 'a'+i);
printf(");\n");
meta();
printf("end.\n");
if (m != 0)
printf("\n");
}
fflush(stdout);
return 0;
}
void TestTest::testScheme() {
std::shared_ptr<schememetadata> meta( new schememetadata(QString("META_RENKOUGAIYAO")) );
std::shared_ptr<schememetadata> meta1( new schememetadata(QString("META_FUFUZINV")));
std::shared_ptr<SchemeBuffer> buffer(new SchemeBuffer);
SchemePtr test(new Scheme(meta, buffer, "上海农业人口概要_回归分释_多龄_农d11p15_非d11p15_z"));
SchemePtr test2(new Scheme(meta, buffer, "K:\\demography\\data\\sim\\0926\\上海农业人口概要_回归分释_多龄_农d11p15_非d11p15_z"));
SchemePtr test3(new Scheme(meta, buffer, "上海农业人口概要_回归分释_多龄_农d11p15_非d11p15_z.txt"));
SchemePtr test4(new Scheme(meta, buffer, "K:\\demography\\data\\sim\\0926\\上海农业人口概要_回归分释_多龄_农d11p15_非d11p15_z.txt"));
try {
qDebug() << "internal " << test->toInternalName();
dbtest(test, 2014, 12);
qDebug() << "internal " << test2->toInternalName();
dbtest(test2, 2014, 12);
dbtest(test3, 2014, 115);
dbtest(test4, 2014, 115);
} catch (const ValueNotExist&e) {
qDebug() << e.value();
} catch (const ColNotExist& e) {
qDebug() << e.value() << e.index();
} catch (const RecordNotExist& e) {
qDebug() << "record not exist" << e.name();
}
}
void preview(struct playlist list) {
struct tracknode * node;
unsigned n = 0;
if (list.track != NULL)
node = list.track->next;
else
{
puts("No tracks in queue.");
return;
}
if(node == NULL) {
puts("No tracks in queue.");
}
else {
puts("Upcoming tracks:");
while(node != NULL) {
const char * format;
format = haskey(& rc, "preview-format")
? value(& rc, "preview-format")
: "%a - %t";
printf("%2d %s\n", n++, meta(format, M_COLORED, & node->track));
node = node->next;
}
}
}
inline void fillBoundingVolumesUsingNodesFromFile(
MPI_Comm comm, const std::string& sphereFilename, FlaotBoxVector &spheres)
{
const int spatialDim = 3;
stk::mesh::MetaData meta(spatialDim);
stk::mesh::BulkData bulk(meta, comm);
stk::io::fill_mesh(sphereFilename, bulk);
stk::mesh::EntityVector nodes;
stk::mesh::get_selected_entities(meta.locally_owned_part(), bulk.buckets(stk::topology::NODE_RANK), nodes);
spheres.clear();
spheres.resize(nodes.size());
stk::mesh::FieldBase const * coords = meta.coordinate_field();
for (size_t i=0;i<nodes.size();i++)
{
stk::mesh::Entity node = nodes[i];
double *data = static_cast<double*>(stk::mesh::field_data(*coords, node));
double x=data[0];
double y=data[1];
double z=data[2];
double radius=1e-5;
unsigned id = bulk.identifier(node);
FloatBox box(x-radius, y-radius, z-radius, x+radius, y+radius, z+radius);
spheres[i] = std::make_pair(box, Ident(id, bulk.parallel_rank()));
}
}
SCREEN *_terminfo_new_screen(const char *term_type, FILE *out, FILE *in)
{
SCREEN *_newscr;
ggLock(ncurses_lock);
if ( term_type == NULL ) {
term_type = getenv("TERM");
if ( term_type == NULL ) {
term_type = "vt100";
}
}
{ char *temp;
temp = (char *)malloc(sizeof(char) * ( strlen(term_type) + 1 ));
strcpy(temp, term_type);
_newscr = newterm(temp, out, in);
free(temp);
}
if ( _newscr == NULL ) {
ggUnlock(ncurses_lock);
} else {
ncurses_screen = _newscr;
set_term(_newscr);
start_color();
cbreak();
noecho();
nonl();
timeout(0);
meta(stdscr, TRUE);
keypad(stdscr, TRUE);
}
return _newscr;
}
void set_default_win_opts(WINDOW *win) {
leaveok(win, FALSE);
scrollok(win, FALSE);
meta(win, TRUE);
keypad(win, TRUE);
idlok(win, TRUE);
}
static void append_engine(gchar * dlname)
{
gchar * can;
gchar * err;
(void) dlerror();
void * hand = dlopen(dlname,RTLD_NOW);
err = dlerror();
if (!hand || err)
{
g_warning(err);
if (hand)
dlclose(hand);
return;
}
can = canonize_name(dlname);
if (engine_is_unique(can))
{
layout_settings_proc lay;
lay = dlsym(hand,"layout_engine_settings");
if ((err=dlerror()))
g_warning(err);
if (lay)
{
get_meta_info_proc meta;
EngineData * d = malloc(sizeof(EngineData));
GtkTreeIter i;
const gchar * format =
"<b>%s</b> (%s)\n"
"<i><small>%s</small></i>";
meta = dlsym(hand,"get_meta_info");
if ((err=dlerror()))
g_warning(err);
d->meta.description=g_strdup("No Description");
d->meta.version=g_strdup("0.0");
d->meta.last_compat=g_strdup("0.0");
d->meta.icon=gtk_widget_render_icon(EngineCombo,GTK_STOCK_MISSING_IMAGE,
GTK_ICON_SIZE_LARGE_TOOLBAR,"themeengine");
if (meta)
meta(&(d->meta));
else
g_warning("Engine %s has no meta info, please update it, using defaults.",dlname);
d->dlname = dlname;
d->canname = can;
d->vbox = gtk_vbox_new(FALSE,2);
g_object_ref(d->vbox);
lay(d->vbox);
EngineList = g_slist_append(EngineList,d);
gtk_list_store_append(EngineModel,&i);
gtk_list_store_set(EngineModel,&i,ENGINE_COL_DLNAME,d->dlname,ENGINE_COL_NAME,d->canname,
ENGINE_COL_VER,d->meta.version,ENGINE_COL_LAST_COMPAT,d->meta.last_compat,
ENGINE_COL_ICON,d->meta.icon,ENGINE_COL_MARKUP,
g_markup_printf_escaped(format,d->canname,d->meta.version,d->meta.description),
-1);
//gtk_combo_box_prepend_text(GTK_COMBO_BOX(EngineCombo),d->canname);
}
}
dlclose(hand);
}
bool AssignTemplate::toolOperations()
{
if (!loadToDImg())
{
return false;
}
QString title = settings()["TemplateTitle"].toString();
DMetadata meta(image().getMetadata());
if (title == Template::removeTemplateTitle())
{
meta.removeMetadataTemplate();
}
else if (title.isEmpty())
{
// Nothing to do.
}
else
{
Template t = TemplateManager::defaultManager()->findByTitle(title);
meta.removeMetadataTemplate();
meta.setMetadataTemplate(t);
}
image().setMetadata(meta.data());
return (savefromDImg());
}
static void AppendAsChildren( const spINode & contextNode, const spINode & parsedNode ) {
if ( !contextNode )
NOTIFY_ERROR( IError::kEDParser, kPECInvalidContextNode, "Context Node is invalid", IError::kESOperationFatal, false, false );
auto contextNodeType = contextNode->GetNodeType();
if ( contextNodeType != INode::kNTStructure && contextNodeType != INode::kNTArray )
NOTIFY_ERROR( IError::kEDParser, kPECContextNodeIsNonComposite, "Context Node is non composite", IError::kESOperationFatal,
true, static_cast< sizet >( contextNodeType ) );
pICompositeNode compositeContextNode = contextNode->GetInterfacePointer< ICompositeNode >();
pIMetadata meta( NULL );
try {
meta = parsedNode->GetInterfacePointer< IMetadata >();
} catch ( spcIError err ) {
meta = NULL;
}
if ( meta ) {
auto it = meta->Iterator();
while ( it ) {
auto childNode = it->GetNode();
it = it->Next();
childNode = meta->GetIMetadata_I()->RemoveNode( childNode->GetNameSpace(), childNode->GetName() );
compositeContextNode->AppendNode( childNode );
}
} else {
compositeContextNode->AppendNode( parsedNode );
}
}
