void Simulation::setOutputDevice(int index, int channels, float minLatency, float startLatency, float maxLatency) {
if(index < -1) ERROR(Lav_ERROR_RANGE, "Index -1 is default; all other negative numbers are invalid.");
if(output_device) {
output_device->stop();
}
std::lock_guard<std::recursive_mutex> g(mutex);
auto factory = getOutputDeviceFactory();
if(factory == nullptr) ERROR(Lav_ERROR_CANNOT_INIT_AUDIO, "Failed to get output device factory.");
auto sptr = std::static_pointer_cast<Simulation>(shared_from_this());
std::weak_ptr<Simulation> wptr(sptr);
int blockSize=getBlockSize();
auto cb =[wptr, blockSize](float* buffer, int channels)->void {
auto strong =wptr.lock();
if(strong==nullptr) memset(buffer, 0, sizeof(float)*blockSize*channels);
else {
std::lock_guard<Simulation> guard(*strong);
strong->getBlock(buffer, channels);
}
};
std::shared_ptr<audio_io::OutputDevice> dev;
try {
dev =factory->createDevice(cb, index, channels, getSr(), getBlockSize(), minLatency, startLatency, maxLatency);
if(dev == nullptr) ERROR(Lav_ERROR_CANNOT_INIT_AUDIO, "Device could not be created.");
}
catch(std::exception &e) {
ERROR(Lav_ERROR_CANNOT_INIT_AUDIO, e.what());
}
output_device=dev;
}
/*! Insert an element into the set
\param what pointer to element to insert
\return result with iterator to insert location and true or end() and false */
result insert(const_iterator what)
{
if (!_sz)
{
_arr = new T[_rsz];
memcpy(_arr, what, sizeof(T));
++_sz;
return result(_arr, true);
}
bool answer;
iterator where(find(*what, answer));
if (answer)
return result(end(), false);
if (_sz < _rsz)
{
memmove(where + 1, where, (end() - where) * sizeof(T));
memcpy(where, what, sizeof(T));
}
else
{
iterator new_arr(new T[_rsz = _sz + calc_reserve(_sz, _reserve)]);
size_t wptr(where - _arr);
if (wptr > 0)
memcpy(new_arr, _arr, sizeof(T) * wptr);
memcpy(new_arr + wptr, what, sizeof(T));
memcpy(new_arr + wptr + 1, where, (end() - where) * sizeof(T));
delete[] _arr;
_arr = new_arr;
}
++_sz;
return result(where, true);
}
EXPORT_C HBufC* LtkUtils::HexDumpL(const TDesC8& aBuf)
{
TInt numLines = (aBuf.Length() + KLineSize-1) / KLineSize;
HBufC* result = HBufC::NewLC(numLines * KTotalLen);
TPtr resultPtr = result->Des();
for (TInt i = 0; i < aBuf.Length(); i += KLineSize)
{
TPtrC8 line = aBuf.Mid(i, Min(KLineSize, aBuf.Length()-i));
TPtr wptr((TUint16*)resultPtr.Ptr() + resultPtr.Length(), KTotalLen);
HexDumpLine(line, wptr, i);
resultPtr.SetLength(resultPtr.Length() + wptr.Length()); // MidTPtr doesn't update length of original
}
CleanupStack::Pop(result);
return result;
}
void Simulation::setOutputDevice(int index, int channels, int mixahead) {
if(index < -1) ERROR(Lav_ERROR_RANGE, "Index -1 is default; all other negative numbers are invalid.");
auto factory = getOutputDeviceFactory();
if(factory == nullptr) ERROR(Lav_ERROR_CANNOT_INIT_AUDIO, "Failed to get output device factory.");
auto sptr = std::static_pointer_cast<Simulation>(shared_from_this());
std::weak_ptr<Simulation> wptr(sptr);
int blockSize=getBlockSize();
auto cb =[wptr, blockSize](float* buffer, int channels)->void {
auto strong =wptr.lock();
if(strong==nullptr) memset(buffer, 0, sizeof(float)*blockSize*channels);
else {
std::lock_guard<Simulation> guard(*strong);
strong->getBlock(buffer, channels);
}
};
auto dev =factory->createDevice(cb, index, channels, getSr(), getBlockSize(), mixahead);
if(dev == nullptr) ERROR(Lav_ERROR_CANNOT_INIT_AUDIO, "Device could not be created.");
output_device=dev;
}
bool Epoll_Engine::GetSocket(unsigned long fd,unsigned long ctime,basesocket_sptr & s)
{
MutexLockGuard lock(&m_mutex);
if(fd >= 0)
{
//LOGDEBUG("debug","GetSocket fd %u,ctime %u",fd,ctime);
if(fds[fd])
{
tr1::weak_ptr<BaseSocket> wptr(fds[fd]);
s = wptr.lock();
if(s)
{
if(s->GetCtime() == ctime)
{
return true;
}
else
s.reset();
}
}
}
return false;
}
void safemode::show( const std::string &custom_name_in, bool is_safemode_in )
{
auto global_rules_old = global_rules;
auto character_rules_old = character_rules;
const int header_height = 4;
const int content_height = FULL_SCREEN_HEIGHT - 2 - header_height;
const int offset_x = ( TERMX > FULL_SCREEN_WIDTH ) ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
const int offset_y = ( TERMY > FULL_SCREEN_HEIGHT ) ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
enum Columns : int {
COLUMN_RULE,
COLUMN_ATTITUDE,
COLUMN_PROXIMITY,
COLUMN_WHITE_BLACKLIST,
};
std::map<int, int> column_pos;
column_pos[COLUMN_RULE] = 4;
column_pos[COLUMN_ATTITUDE] = 48;
column_pos[COLUMN_PROXIMITY] = 59;
column_pos[COLUMN_WHITE_BLACKLIST] = 66;
const int num_columns = column_pos.size();
WINDOW *w_help = newwin( ( FULL_SCREEN_HEIGHT / 2 ) - 2, FULL_SCREEN_WIDTH * 3 / 4,
7 + offset_y + ( FULL_SCREEN_HEIGHT / 2 ) / 2, offset_x + 19 / 2 );
WINDOW_PTR w_helpptr( w_help );
WINDOW *w_border = newwin( FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, offset_y, offset_x );
WINDOW_PTR w_borderptr( w_border );
WINDOW *w_header = newwin( header_height, FULL_SCREEN_WIDTH - 2, 1 + offset_y,
1 + offset_x );
WINDOW_PTR w_headerptr( w_header );
WINDOW *w = newwin( content_height, FULL_SCREEN_WIDTH - 2, header_height + 1 + offset_y,
1 + offset_x );
WINDOW_PTR wptr( w );
draw_border( w_border, BORDER_COLOR, custom_name_in );
mvwputch( w_border, 3, 0, c_ltgray, LINE_XXXO ); // |-
mvwputch( w_border, 3, 79, c_ltgray, LINE_XOXX ); // -|
for( auto &column : column_pos ) {
mvwputch( w_border, FULL_SCREEN_HEIGHT - 1, column.second + 1, c_ltgray,
LINE_XXOX ); // _|_
}
wrefresh( w_border );
static const std::vector<std::string> hotkeys = {{
_( "<A>dd" ), _( "<R>emove" ), _( "<C>opy" ), _( "<M>ove" ),
_( "<E>nable" ), _( "<D>isable" ), _( "<T>est" )
}
};
int tmpx = 0;
for( auto &hotkey : hotkeys ) {
tmpx += shortcut_print( w_header, 0, tmpx, c_white, c_ltgreen, hotkey ) + 2;
}
tmpx = 0;
tmpx += shortcut_print( w_header, 1, tmpx, c_white, c_ltgreen, _( "<+-> Move up/down" ) ) + 2;
tmpx += shortcut_print( w_header, 1, tmpx, c_white, c_ltgreen, _( "<Enter>-Edit" ) ) + 2;
shortcut_print( w_header, 1, tmpx, c_white, c_ltgreen, _( "<Tab>-Switch Page" ) );
for( int i = 0; i < 78; i++ ) {
mvwputch( w_header, 2, i, c_ltgray, LINE_OXOX ); // Draw line under header
}
for( auto &pos : column_pos ) {
mvwputch( w_header, 2, pos.second, c_ltgray, LINE_OXXX );
mvwputch( w_header, 3, pos.second, c_ltgray, LINE_XOXO );
}
mvwprintz( w_header, 3, 1, c_white, "#" );
mvwprintz( w_header, 3, column_pos[COLUMN_RULE] + 4, c_white, _( "Rules" ) );
mvwprintz( w_header, 3, column_pos[COLUMN_ATTITUDE] + 2, c_white, _( "Attitude" ) );
mvwprintz( w_header, 3, column_pos[COLUMN_PROXIMITY] + 2, c_white, _( "Dist" ) );
mvwprintz( w_header, 3, column_pos[COLUMN_WHITE_BLACKLIST] + 2, c_white, _( "B/W" ) );
wrefresh( w_header );
int tab = GLOBAL_TAB;
int line = 0;
int column = 0;
int start_pos = 0;
bool changes_made = false;
input_context ctxt( "SAFEMODE" );
ctxt.register_cardinal();
ctxt.register_action( "CONFIRM" );
ctxt.register_action( "QUIT" );
ctxt.register_action( "NEXT_TAB" );
ctxt.register_action( "PREV_TAB" );
ctxt.register_action( "ADD_DEFAULT_RULESET" );
ctxt.register_action( "ADD_RULE" );
ctxt.register_action( "REMOVE_RULE" );
ctxt.register_action( "COPY_RULE" );
ctxt.register_action( "ENABLE_RULE" );
ctxt.register_action( "DISABLE_RULE" );
ctxt.register_action( "MOVE_RULE_UP" );
ctxt.register_action( "MOVE_RULE_DOWN" );
ctxt.register_action( "TEST_RULE" );
ctxt.register_action( "HELP_KEYBINDINGS" );
if( is_safemode_in ) {
ctxt.register_action( "SWITCH_SAFEMODE_OPTION" );
ctxt.register_action( "SWAP_RULE_GLOBAL_CHAR" );
}
while( true ) {
int locx = 17;
locx += shortcut_print( w_header, 2, locx, c_white,
( tab == GLOBAL_TAB ) ? hilite( c_white ) : c_white, _( "[<Global>]" ) ) + 1;
shortcut_print( w_header, 2, locx, c_white,
( tab == CHARACTER_TAB ) ? hilite( c_white ) : c_white, _( "[<Character>]" ) );
locx = 55;
mvwprintz( w_header, 0, locx, c_white, _( "Safe Mode enabled:" ) );
locx += shortcut_print( w_header, 1, locx,
( ( get_option<bool>( "SAFEMODE" ) ) ? c_ltgreen : c_ltred ), c_white,
( ( get_option<bool>( "SAFEMODE" ) ) ? _( "True" ) : _( "False" ) ) );
locx += shortcut_print( w_header, 1, locx, c_white, c_ltgreen, " " );
locx += shortcut_print( w_header, 1, locx, c_white, c_ltgreen, _( "<S>witch" ) );
shortcut_print( w_header, 1, locx, c_white, c_ltgreen, " " );
wrefresh( w_header );
// Clear the lines
for( int i = 0; i < content_height; i++ ) {
for( int j = 0; j < 79; j++ ) {
mvwputch( w, i, j, c_black, ' ' );
}
for( auto &pos : column_pos ) {
mvwputch( w, i, pos.second, c_ltgray, LINE_XOXO );
}
}
auto ¤t_tab = ( tab == GLOBAL_TAB ) ? global_rules : character_rules;
if( tab == CHARACTER_TAB && g->u.name.empty() ) {
character_rules.clear();
mvwprintz( w, 8, 15, c_white, _( "Please load a character first to use this page!" ) );
} else if( empty() ) {
mvwprintz( w, 8, 15, c_white, _( "Safe Mode manager currently inactive." ) );
mvwprintz( w, 9, 15, c_white, _( "Default rules are used. Add a rule to activate." ) );
mvwprintz( w, 10, 15, c_white, _( "Press ~ to add a default ruleset to get started." ) );
}
draw_scrollbar( w_border, line, content_height, current_tab.size(), 5 );
wrefresh( w_border );
calcStartPos( start_pos, line, content_height, current_tab.size() );
// display safe mode
for( int i = start_pos; i < ( int )current_tab.size(); i++ ) {
if( i >= start_pos &&
i < start_pos + std::min( content_height, static_cast<int>( current_tab.size() ) ) ) {
auto rule = current_tab[i];
nc_color line_color = ( rule.active ) ? c_white : c_ltgray;
mvwprintz( w, i - start_pos, 1, line_color, "%d", i + 1 );
mvwprintz( w, i - start_pos, 5, c_yellow, ( line == i ) ? ">> " : " " );
auto draw_column = [&]( Columns column_in, std::string text_in ) {
mvwprintz( w, i - start_pos, column_pos[column_in] + 2,
( line == i && column == column_in ) ? hilite( line_color ) : line_color,
"%s", text_in.c_str()
);
};
draw_column( COLUMN_RULE, ( rule.rule.empty() ) ? _( "<empty rule>" ) : rule.rule );
draw_column( COLUMN_ATTITUDE, Creature::get_attitude_ui_data( rule.attitude ).first );
draw_column( COLUMN_PROXIMITY, ( !rule.whitelist ) ? to_string( rule.proximity ).c_str() : "---" );
draw_column( COLUMN_WHITE_BLACKLIST, ( rule.whitelist ) ? _( "Whitelist" ) : _( "Blacklist" ) );
}
}
wrefresh( w );
const std::string action = ctxt.handle_input();
if( action == "NEXT_TAB" ) {
tab++;
if( tab >= MAX_TAB ) {
tab = 0;
line = 0;
}
} else if( action == "PREV_TAB" ) {
tab--;
if( tab < 0 ) {
tab = MAX_TAB - 1;
line = 0;
}
} else if( action == "QUIT" ) {
break;
} else if( tab == CHARACTER_TAB && g->u.name.empty() ) {
//Only allow loaded games to use the char sheet
} else if( action == "DOWN" ) {
line++;
if( line >= ( int )current_tab.size() ) {
line = 0;
}
} else if( action == "UP" ) {
line--;
if( line < 0 ) {
line = current_tab.size() - 1;
}
} else if( action == "ADD_DEFAULT_RULESET" ) {
changes_made = true;
current_tab.push_back( rules_class( "*", true, false, Creature::A_HOSTILE, 0 ) );
line = current_tab.size() - 1;
} else if( action == "ADD_RULE" ) {
changes_made = true;
current_tab.push_back( rules_class( "", true, false, Creature::A_HOSTILE,
get_option<int>( "SAFEMODEPROXIMITY" ) ) );
line = current_tab.size() - 1;
} else if( action == "REMOVE_RULE" && !current_tab.empty() ) {
changes_made = true;
current_tab.erase( current_tab.begin() + line );
if( line > ( int )current_tab.size() - 1 ) {
line--;
}
if( line < 0 ) {
line = 0;
}
} else if( action == "COPY_RULE" && !current_tab.empty() ) {
changes_made = true;
current_tab.push_back( current_tab[line] );
line = current_tab.size() - 1;
} else if( action == "SWAP_RULE_GLOBAL_CHAR" && !current_tab.empty() ) {
if( ( tab == GLOBAL_TAB && !g->u.name.empty() ) || tab == CHARACTER_TAB ) {
changes_made = true;
//copy over
auto &temp_rules_from = ( tab == GLOBAL_TAB ) ? global_rules : character_rules;
auto &temp_rules_to = ( tab == GLOBAL_TAB ) ? character_rules : global_rules;
temp_rules_to.push_back( temp_rules_from[line] );
//remove old
temp_rules_from.erase( temp_rules_from.begin() + line );
line = temp_rules_from.size() - 1;
tab = ( tab == GLOBAL_TAB ) ? CHARACTER_TAB : GLOBAL_TAB;
}
} else if( action == "CONFIRM" && !current_tab.empty() ) {
changes_made = true;
if( column == COLUMN_RULE ) {
fold_and_print( w_help, 1, 1, 999, c_white,
_(
"* is used as a Wildcard. A few Examples:\n"
"\n"
"human matches every NPC\n"
"zombie matches the monster name exactly\n"
"acidic zo* matches monsters beginning with 'acidic zo'\n"
"*mbie matches monsters ending with 'mbie'\n"
"*cid*zo*ie multiple * are allowed\n"
"AcI*zO*iE case insensitive search" )
);
draw_border( w_help );
wrefresh( w_help );
current_tab[line].rule = wildcard_trim_rule( string_input_popup()
.title( _( "Safe Mode Rule:" ) )
.width( 30 )
.text( current_tab[line].rule )
.query_string() );
} else if( column == COLUMN_WHITE_BLACKLIST ) {
current_tab[line].whitelist = !current_tab[line].whitelist;
} else if( column == COLUMN_ATTITUDE ) {
auto &attitude = current_tab[line].attitude;
switch( attitude ) {
case Creature::A_HOSTILE:
attitude = Creature::A_NEUTRAL;
break;
case Creature::A_NEUTRAL:
attitude = Creature::A_FRIENDLY;
break;
case Creature::A_FRIENDLY:
attitude = Creature::A_ANY;
break;
case Creature::A_ANY:
attitude = Creature::A_HOSTILE;
}
} else if( column == COLUMN_PROXIMITY && !current_tab[line].whitelist ) {
const auto text = string_input_popup()
.title( _( "Proximity Distance (0=max viewdistance)" ) )
.width( 4 )
.text( to_string( current_tab[line].proximity ) )
.description( _( "Option: " ) + to_string( get_option<int>( "SAFEMODEPROXIMITY" ) ) +
" " + get_options().get_option( "SAFEMODEPROXIMITY" ).getDefaultText() )
.max_length( 3 )
.only_digits( true )
.query_string();
if( text.empty() ) {
current_tab[line].proximity = get_option<int>( "SAFEMODEPROXIMITY" );
} else {
//Let the options class handle the validity of the new value
auto temp_option = get_options().get_option( "SAFEMODEPROXIMITY" );
temp_option.setValue( text );
current_tab[line].proximity = atoi( temp_option.getValue().c_str() );
}
}
} else if( action == "ENABLE_RULE" && !current_tab.empty() ) {
changes_made = true;
current_tab[line].active = true;
} else if( action == "DISABLE_RULE" && !current_tab.empty() ) {
changes_made = true;
current_tab[line].active = false;
} else if( action == "LEFT" ) {
column--;
if( column < 0 ) {
column = num_columns - 1;
}
} else if( action == "RIGHT" ) {
column++;
if( column >= num_columns ) {
column = 0;
}
} else if( action == "MOVE_RULE_UP" && !current_tab.empty() ) {
changes_made = true;
if( line < ( int )current_tab.size() - 1 ) {
std::swap( current_tab[line], current_tab[line + 1] );
line++;
column = 0;
}
} else if( action == "MOVE_RULE_DOWN" && !current_tab.empty() ) {
changes_made = true;
if( line > 0 ) {
std::swap( current_tab[line], current_tab[line - 1] );
line--;
column = 0;
}
} else if( action == "TEST_RULE" && !current_tab.empty() ) {
test_pattern( tab, line );
} else if( action == "SWITCH_SAFEMODE_OPTION" ) {
get_options().get_option( "SAFEMODE" ).setNext();
get_options().save();
}
}
if( !changes_made ) {
return;
}
if( query_yn( _( "Save changes?" ) ) ) {
if( is_safemode_in ) {
save_global();
if( !g->u.name.empty() ) {
save_character();
}
} else {
create_rules();
}
} else {
global_rules = global_rules_old;
character_rules = character_rules_old;
}
}
void auto_pickup::show( const std::string &custom_name, bool is_autopickup )
{
save_reset_changes(false);
const int iHeaderHeight = 4;
const int iContentHeight = FULL_SCREEN_HEIGHT - 2 - iHeaderHeight;
const int iOffsetX = (TERMX > FULL_SCREEN_WIDTH) ? (TERMX - FULL_SCREEN_WIDTH) / 2 : 0;
const int iOffsetY = (TERMY > FULL_SCREEN_HEIGHT) ? (TERMY - FULL_SCREEN_HEIGHT) / 2 : 0;
std::map<int, bool> mapLines;
mapLines[4] = true;
mapLines[50] = true;
mapLines[54] = true;
const int iTotalCols = mapLines.size() - 1;
WINDOW *w_help = newwin((FULL_SCREEN_HEIGHT / 2) - 2, FULL_SCREEN_WIDTH * 3 / 4,
7 + iOffsetY + (FULL_SCREEN_HEIGHT / 2) / 2, iOffsetX + 19 / 2);
WINDOW_PTR w_helpptr( w_help );
WINDOW *w_border = newwin(FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, iOffsetY, iOffsetX);
WINDOW_PTR w_borderptr( w_border );
WINDOW *w_header = newwin(iHeaderHeight, FULL_SCREEN_WIDTH - 2, 1 + iOffsetY,
1 + iOffsetX);
WINDOW_PTR w_headerptr( w_header );
WINDOW *w = newwin(iContentHeight, FULL_SCREEN_WIDTH - 2, iHeaderHeight + 1 + iOffsetY,
1 + iOffsetX);
WINDOW_PTR wptr( w );
draw_border(w_border);
mvwputch(w_border, 3, 0, c_ltgray, LINE_XXXO); // |-
mvwputch(w_border, 3, 79, c_ltgray, LINE_XOXX); // -|
for( auto &mapLine : mapLines ) {
mvwputch( w_border, FULL_SCREEN_HEIGHT - 1, mapLine.first + 1, c_ltgray,
LINE_XXOX ); // _|_
}
mvwprintz(w_border, 0, 29, c_ltred, custom_name.c_str() );
wrefresh(w_border);
int tmpx = 0;
tmpx += shortcut_print(w_header, 0, tmpx, c_white, c_ltgreen, _("<A>dd")) + 2;
tmpx += shortcut_print(w_header, 0, tmpx, c_white, c_ltgreen, _("<R>emove")) + 2;
tmpx += shortcut_print(w_header, 0, tmpx, c_white, c_ltgreen, _("<C>opy")) + 2;
tmpx += shortcut_print(w_header, 0, tmpx, c_white, c_ltgreen, _("<M>ove")) + 2;
tmpx += shortcut_print(w_header, 0, tmpx, c_white, c_ltgreen, _("<E>nable")) + 2;
tmpx += shortcut_print(w_header, 0, tmpx, c_white, c_ltgreen, _("<D>isable")) + 2;
shortcut_print(w_header, 0, tmpx, c_white, c_ltgreen, _("<T>est"));
tmpx = 0;
tmpx += shortcut_print(w_header, 1, tmpx, c_white, c_ltgreen,
_("<+-> Move up/down")) + 2;
tmpx += shortcut_print(w_header, 1, tmpx, c_white, c_ltgreen, _("<Enter>-Edit")) + 2;
shortcut_print(w_header, 1, tmpx, c_white, c_ltgreen, _("<Tab>-Switch Page"));
for (int i = 0; i < 78; i++) {
if (mapLines[i]) {
mvwputch(w_header, 2, i, c_ltgray, LINE_OXXX);
mvwputch(w_header, 3, i, c_ltgray, LINE_XOXO);
} else {
mvwputch(w_header, 2, i, c_ltgray, LINE_OXOX); // Draw line under header
}
}
mvwprintz(w_header, 3, 1, c_white, "#");
mvwprintz(w_header, 3, 8, c_white, _("Rules"));
mvwprintz(w_header, 3, 51, c_white, _("I/E"));
wrefresh(w_header);
int iCurrentPage = 1;
int iCurrentLine = 0;
int iCurrentCol = 1;
int iStartPos = 0;
bool bStuffChanged = false;
input_context ctxt("AUTO_PICKUP");
ctxt.register_cardinal();
ctxt.register_action("CONFIRM");
ctxt.register_action("QUIT");
ctxt.register_action("NEXT_TAB");
ctxt.register_action("PREV_TAB");
ctxt.register_action("ADD_RULE");
ctxt.register_action("REMOVE_RULE");
ctxt.register_action("COPY_RULE");
ctxt.register_action("ENABLE_RULE");
ctxt.register_action("DISABLE_RULE");
ctxt.register_action("MOVE_RULE_UP");
ctxt.register_action("MOVE_RULE_DOWN");
ctxt.register_action("TEST_RULE");
ctxt.register_action("HELP_KEYBINDINGS");
if( is_autopickup ) {
ctxt.register_action("SWITCH_AUTO_PICKUP_OPTION");
ctxt.register_action("SWAP_RULE_GLOBAL_CHAR");
}
std::ostringstream sTemp;
while(true) {
int locx = 17;
locx += shortcut_print(w_header, 2, locx, c_white,
(iCurrentPage == 1) ? hilite(c_white) : c_white, _("[<Global>]")) + 1;
shortcut_print(w_header, 2, locx, c_white,
(iCurrentPage == 2) ? hilite(c_white) : c_white, _("[<Character>]"));
locx = 55;
mvwprintz(w_header, 0, locx, c_white, _("Auto pickup enabled:"));
locx += shortcut_print(w_header, 1, locx,
((OPTIONS["AUTO_PICKUP"]) ? c_ltgreen : c_ltred), c_white,
((OPTIONS["AUTO_PICKUP"]) ? _("True") : _("False")));
locx += shortcut_print(w_header, 1, locx, c_white, c_ltgreen, " ");
locx += shortcut_print(w_header, 1, locx, c_white, c_ltgreen, _("<S>witch"));
shortcut_print(w_header, 1, locx, c_white, c_ltgreen, " ");
wrefresh(w_header);
// Clear the lines
for (int i = 0; i < iContentHeight; i++) {
for (int j = 0; j < 79; j++) {
if (mapLines[j]) {
mvwputch(w, i, j, c_ltgray, LINE_XOXO);
} else {
mvwputch(w, i, j, c_black, ' ');
}
}
}
const bool currentPageNonEmpty = !vRules[iCurrentPage].empty();
if (iCurrentPage == 2 && g->u.name == "") {
vRules[2].clear();
mvwprintz(w, 8, 15, c_white,
_("Please load a character first to use this page!"));
}
draw_scrollbar(w_border, iCurrentLine, iContentHeight,
vRules[iCurrentPage].size(), 5);
wrefresh(w_border);
calcStartPos(iStartPos, iCurrentLine, iContentHeight,
vRules[iCurrentPage].size());
// display auto pickup
for (int i = iStartPos; i < (int)vRules[iCurrentPage].size(); i++) {
if (i >= iStartPos &&
i < iStartPos + ((iContentHeight > (int)vRules[iCurrentPage].size()) ?
(int)vRules[iCurrentPage].size() : iContentHeight)) {
nc_color cLineColor = (vRules[iCurrentPage][i].bActive) ?
c_white : c_ltgray;
sTemp.str("");
sTemp << i + 1;
mvwprintz(w, i - iStartPos, 1, cLineColor, "%s", sTemp.str().c_str());
mvwprintz(w, i - iStartPos, 5, cLineColor, "");
if (iCurrentLine == i) {
wprintz(w, c_yellow, ">> ");
} else {
wprintz(w, c_yellow, " ");
}
wprintz(w, (iCurrentLine == i &&
iCurrentCol == 1) ? hilite(cLineColor) : cLineColor, "%s",
((vRules[iCurrentPage][i].sRule == "") ? _("<empty rule>") :
vRules[iCurrentPage][i].sRule).c_str());
mvwprintz(w, i - iStartPos, 52, (iCurrentLine == i &&
iCurrentCol == 2) ? hilite(cLineColor) : cLineColor, "%s",
((vRules[iCurrentPage][i].bExclude) ? rm_prefix(_("<Exclude>E")).c_str() : rm_prefix(
_("<Include>I")).c_str()));
}
}
wrefresh(w);
const std::string action = ctxt.handle_input();
if (action == "NEXT_TAB") {
iCurrentPage++;
if (iCurrentPage > 2) {
iCurrentPage = 1;
iCurrentLine = 0;
}
} else if (action == "PREV_TAB") {
iCurrentPage--;
if (iCurrentPage < 1) {
iCurrentPage = 2;
iCurrentLine = 0;
}
} else if (action == "QUIT") {
break;
} else if (iCurrentPage == 2 && g->u.name.empty()) {
//Only allow loaded games to use the char sheet
} else if (action == "DOWN") {
iCurrentLine++;
iCurrentCol = 1;
if (iCurrentLine >= (int)vRules[iCurrentPage].size()) {
iCurrentLine = 0;
}
} else if (action == "UP") {
iCurrentLine--;
iCurrentCol = 1;
if (iCurrentLine < 0) {
iCurrentLine = vRules[iCurrentPage].size() - 1;
}
} else if (action == "ADD_RULE") {
bStuffChanged = true;
vRules[iCurrentPage].push_back(cRules("", true, false));
iCurrentLine = vRules[iCurrentPage].size() - 1;
} else if (action == "REMOVE_RULE" && currentPageNonEmpty) {
bStuffChanged = true;
vRules[iCurrentPage].erase(vRules[iCurrentPage].begin() + iCurrentLine);
if (iCurrentLine > (int)vRules[iCurrentPage].size() - 1) {
iCurrentLine--;
}
if(iCurrentLine < 0){
iCurrentLine = 0;
}
} else if (action == "COPY_RULE" && currentPageNonEmpty) {
bStuffChanged = true;
vRules[iCurrentPage].push_back(cRules(
vRules[iCurrentPage][iCurrentLine].sRule,
vRules[iCurrentPage][iCurrentLine].bActive,
vRules[iCurrentPage][iCurrentLine].bExclude));
iCurrentLine = vRules[iCurrentPage].size() - 1;
} else if (action == "SWAP_RULE_GLOBAL_CHAR" && currentPageNonEmpty) {
if ((iCurrentPage == 1 && g->u.name != "") || iCurrentPage == 2) {
bStuffChanged = true;
//copy over
vRules[(iCurrentPage == 1) ? 2 : 1].push_back(cRules(
vRules[iCurrentPage][iCurrentLine].sRule,
vRules[iCurrentPage][iCurrentLine].bActive,
vRules[iCurrentPage][iCurrentLine].bExclude));
//remove old
vRules[iCurrentPage].erase(vRules[iCurrentPage].begin() + iCurrentLine);
iCurrentLine = vRules[(iCurrentPage == 1) ? 2 : 1].size() - 1;
iCurrentPage = (iCurrentPage == 1) ? 2 : 1;
}
} else if (action == "CONFIRM" && currentPageNonEmpty) {
bStuffChanged = true;
if (iCurrentCol == 1) {
fold_and_print(w_help, 1, 1, 999, c_white,
_(
"* is used as a Wildcard. A few Examples:\n"
"\n"
"wooden arrow matches the itemname exactly\n"
"wooden ar* matches items beginning with wood ar\n"
"*rrow matches items ending with rrow\n"
"*avy fle*fi*arrow multiple * are allowed\n"
"heAVY*woOD*arrOW case insensitive search\n"
"")
);
draw_border(w_help);
wrefresh(w_help);
vRules[iCurrentPage][iCurrentLine].sRule = trim_rule(string_input_popup(_("Pickup Rule:"),
30, vRules[iCurrentPage][iCurrentLine].sRule));
} else if (iCurrentCol == 2) {
vRules[iCurrentPage][iCurrentLine].bExclude =
!vRules[iCurrentPage][iCurrentLine].bExclude;
}
} else if (action == "ENABLE_RULE" && currentPageNonEmpty) {
bStuffChanged = true;
vRules[iCurrentPage][iCurrentLine].bActive = true;
} else if (action == "DISABLE_RULE" && currentPageNonEmpty) {
bStuffChanged = true;
vRules[iCurrentPage][iCurrentLine].bActive = false;
} else if (action == "LEFT") {
iCurrentCol--;
if (iCurrentCol < 1) {
iCurrentCol = iTotalCols;
}
} else if (action == "RIGHT") {
iCurrentCol++;
if (iCurrentCol > iTotalCols) {
iCurrentCol = 1;
}
} else if (action == "MOVE_RULE_UP" && currentPageNonEmpty) {
bStuffChanged = true;
if (iCurrentLine < (int)vRules[iCurrentPage].size() - 1) {
std::swap(vRules[iCurrentPage][iCurrentLine],
vRules[iCurrentPage][iCurrentLine + 1]);
iCurrentLine++;
iCurrentCol = 1;
}
} else if (action == "MOVE_RULE_DOWN" && currentPageNonEmpty) {
bStuffChanged = true;
if (iCurrentLine > 0) {
std::swap(vRules[iCurrentPage][iCurrentLine],
vRules[iCurrentPage][iCurrentLine - 1]);
iCurrentLine--;
iCurrentCol = 1;
}
} else if (action == "TEST_RULE" && currentPageNonEmpty) {
test_pattern(iCurrentPage, iCurrentLine);
} else if (action == "SWITCH_OPTION") {
// @todo Now that NPCs use this function, it could be used for them too
OPTIONS["AUTO_PICKUP"].setNext();
get_options().save();
}
}
if( !bStuffChanged ) {
return;
}
if( query_yn( _("Save changes?") ) ) {
// NPC pickup rules don't need to be saved explicitly
if( is_autopickup ) {
save( false );
if( g->u.name != "" ) {
save(true);
}
} else {
merge_vector();
create_rules();
}
} else {
save_reset_changes( true );
}
}
//
// LtkUtils::W32CrackL
// loads the autometric logging engine, dlogev.dll, into wserv
// enabling Autometric to monitor events from within wserv - key/pointer events, text drawn to screen etc
//
EXPORT_C void LtkUtils::W32CrackL()
{
#ifndef FSHELL_WSERV_SUPPORT
User::Leave(KErrNotSupported);
#else
// Check if P&S says it's already enabled, if so no need to do anything
if (W32CrackIsEnabled()) return;
_LIT(KWsIniFile, "z:\\system\\data\\wsini.ini");
_LIT(KCWsIniFile,"c:\\system\\data\\wsini.ini");
_LIT(KLogEv, "LOG EV\r\n");
// Open z file
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
RFile file;
User::LeaveIfError(file.Open(fs, KWsIniFile, EFileRead));
CleanupClosePushL(file);
TInt size;
User::LeaveIfError(file.Size(size));
RBuf8 buf;
buf.CreateL(size + KLogEv().Size());
CleanupClosePushL(buf);
User::LeaveIfError(file.Read(buf));
TPtrC16 wptr((TUint16*)buf.Ptr(), buf.Size()/2);
buf.Insert(2, TPtrC8((TUint8*)KLogEv().Ptr(), KLogEv().Size())); // +2 to get past the BOM
TInt err = KErrNone;
err = fs.MkDirAll(KCWsIniFile); // mkdir c:\system\data\ in case it is not exist
if((err != KErrNone) && (err != KErrAlreadyExists))
{
User::Leave(err);
}
User::LeaveIfError(file.Replace(fs, KCWsIniFile, EFileWrite));
User::LeaveIfError(file.Write(buf));
CleanupStack::PopAndDestroy(2, &file); // file, buf
err = RMemoryAccess::LoadDriver();
if ((err != KErrNone) && (err != KErrAlreadyExists))
{
User::Leave(err);
}
RMemoryAccess memAccess;
User::LeaveIfError(memAccess.Open());
CleanupClosePushL(memAccess);
RWsSession ws;
User::LeaveIfError(ws.Connect(fs));
CleanupClosePushL(ws);
#ifdef __WINS__
// On wins the binary isn't renamed
_LIT(KWservMatch, "wserv*.exe*");
#else
_LIT(KWservMatch, "EwSrv.exe*");
#endif
TFindProcess find(KWservMatch);
TFullName name;
User::LeaveIfError(find.Next(name));
RProcess wservProc;
User::LeaveIfError(wservProc.Open(find));
if (wservProc.ExitType() != EExitPending)
{
// in case wserv kicks off the preferred implementation in a new process then kills itself
// (is one retry enough or should we be looping here?)
wservProc.Close();
User::LeaveIfError(find.Next(name));
User::LeaveIfError(wservProc.Open(find));
}
CleanupClosePushL(wservProc);
name = wservProc.FileName();
name[0] = 'c';
TPtrC8 narrowName = name.Collapse();
User::LeaveIfError(memAccess.InPlaceSetProcessFileName(wservProc, narrowName));
// Now tell wserv to reload its wsini.ini and enable logging
ws.LogCommand(RWsSession::ELoggingEnable);
ws.Flush();
// cleanup
CleanupStack::PopAndDestroy(4, &fs);
#endif // FSHELL_WSERV_SUPPORT
}
EXPORT_C void CUrl::SetComponentL(TComponent aComponent, const TDesC& aValue)
{
TInt start, end;
// As a crude first step, we always resize the URL descriptor to
// be longer than it currently is by 4 characters longer than the
// value. Then at the end, we'll resize it to be the right length.
// 4 allows :// to be inserted if a scheme is set when none is present
iUrlDes=iUrlDes->ReAllocL(iUrlDes->Length() + aValue.Length() + 4);
Part(aComponent, *iUrlDes, start, end);
if (aComponent == EUrlScheme && start == KCUrlInvalidCharPos && end == KCUrlInvalidCharPos)
{ // We're trying to add a scheme, but there isn't one already. Check if scheme valid
// There could already be a // at the start, but there can't be a : at the start
CheckSchemeValidL(aValue);
// insert location if required
TPtr wptr(iUrlDes->Des());
// insert // at the start
if(wptr.Find(KUrlLoc)!=0)
wptr.Insert(0,KUrlLoc);
// insert scheme and a colon
wptr.Insert(0,KUrlColon);
wptr.Insert(0,aValue);
}
else if ((aComponent == EUrlUsername || aComponent == EUrlPassword) &&
(start == KCUrlInvalidCharPos || end == KCUrlInvalidCharPos))
{
// We're trying to add a username or password, but there isn't
// one already, so the surrounding punctuation won't be there.
if (aComponent == EUrlUsername)
{
Part(EUrlAuthority, *iUrlDes, start, end);
// If there isn't an authority, this is too complex.
if (start == KCUrlInvalidCharPos)
User::Leave(KErrNotSupported);
// We've now found the correct start position. Check if
// the password exists
TInt scratch;
Part(EUrlPassword, *iUrlDes, end, scratch);
if (end == KCUrlInvalidCharPos)
{
// No username or password. This means we need to add the @
iUrlDes->Des().Insert(start, _L("@"));
end = start;
}
else
{
// There is a password, so end currently points after
// the colon.
end--;
}
}
else
{
// aComponent == EUrlPassword
TInt scratch;
Part(EUrlUsername, *iUrlDes, scratch, start);
if (start == KCUrlInvalidCharPos)
{
// No username. We need to find the start of the
// location, and add :@ after it and insert the
// password between them.
Part(EUrlLocation, *iUrlDes, start, scratch);
iUrlDes->Des().Insert(start, _L(":@"));
}
else
{
// There is a username but no password. Add a colon at
// the end of it and then add the password afterwards.
iUrlDes->Des().Insert(++start, KUrlColon);
}
start++;
end = start;
}
}
else if (start == KCUrlInvalidCharPos || end == KCUrlInvalidCharPos)
{
// A complex case we can't deal with
User::Leave(KErrNotSupported);
}
else
{
// The easy case; end currently points at the last character;
// we want it to point one after.
end++;
}
if (start != KCUrlInvalidCharPos && end != KCUrlInvalidCharPos)
{ // this check is necessary to catch the case where
// we set a scheme and there wasn't one already
iUrlDes->Des().Replace(start, end - start, aValue);
}
iUrlDes=iUrlDes->ReAllocL(iUrlDes->Length());
}
