int
nmgetch()
/*
This is not perfect, it doesn't move the cursor when goraw changes
over to deraw, but it works well enough since the whole sc package
is incredibly stable (loop constantly positions cursor).
Question, why didn't the VMS people just implement cbreak?
NOTE: During testing it was discovered that the DEBUGGER and curses
and this method of reading would collide (the screen was not updated
when continuing from screen mode in the debugger).
*/
{
short c;
static int key_id=0;
int status;
#define VMScheck(a) {if (~(status = (a)) & 1) VMS_MSG (status);}
if (VMS_read_raw) {
VMScheck(smg$read_keystroke (&stdkb->_id, &c, 0, 0, 0));
} else
c = getchar();
switch (c) {
case SMG$K_TRM_LEFT: c = KEY_LEFT; break;
case SMG$K_TRM_RIGHT: c = KEY_RIGHT; break;
case SMG$K_TRM_UP: c = ctl('p'); break;
case SMG$K_TRM_DOWN: c = ctl('n'); break;
default: c = c & A_CHARTEXT;
}
return (c);
}
void
initkbd()
{
register struct key_map *kp;
register i,j;
char *p = keyarea;
char *ktmp;
static char buf[1024]; /* Why do I have to do this again? */
if (!(ktmp = getenv("TERM"))) {
(void) fprintf(stderr, "TERM environment variable not set\n");
exit (1);
}
if (tgetent(buf, ktmp) <= 0)
return;
km[0].k_str = tgetstr("kl", &p); km[0].k_val = KEY_LEFT;
km[1].k_str = tgetstr("kr", &p); km[1].k_val = KEY_RIGHT;
km[2].k_str = tgetstr("ku", &p); km[2].k_val = ctl('p');
km[3].k_str = tgetstr("kd", &p); km[3].k_val = ctl('n');
ktmp = tgetstr("ks",&p);
if (ktmp) {
(void) strcpy(ks_buf, ktmp);
ks = ks_buf;
tputs(ks, 1, charout);
}
ktmp = tgetstr("ke",&p);
if (ktmp) {
(void) strcpy(ke_buf, ktmp);
ke = ke_buf;
}
/* Unmap arrow keys which conflict with our ctl keys */
/* Ignore unset, longer than length 1, and 1-1 mapped keys */
for (i = 0; i < N_KEY; i++) {
kp = &km[i];
if (kp->k_str && (kp->k_str[1] == 0) && (kp->k_str[0] != kp->k_val))
for (j = 0; dont_use[j] != 0; j++)
if (kp->k_str[0] == dont_use[j]) {
kp->k_str = (char *)0;
break;
}
}
#ifdef TIOCSLTC
(void)ioctl(fileno(stdin), TIOCGLTC, (char *)&old_chars);
new_chars = old_chars;
if (old_chars.t_lnextc == ctl('v'))
new_chars.t_lnextc = -1;
if (old_chars.t_rprntc == ctl('r'))
new_chars.t_rprntc = -1;
(void)ioctl(fileno(stdin), TIOCSLTC, (char *)&new_chars);
#endif
}
static void line_move( int up, int n )
{
static int lastcol;
int ndot;
int col = 1;
int lim = bf_cur->num_characters() + 1;
if( n == 0 )
return;
if( n < 0 )
{
n = -n;
up = ! up;
}
if( up )
n = -n - 1;
if( last_proc != next_line
&& last_proc != previous_line )
lastcol = (track_eol != 0 && dot < lim && bf_cur->char_at (dot) == '\n') ? 9999 : cur_col();
ndot = scan_bf_for_lf( dot, n );
while( col < lastcol && ndot < lim )
{
n = bf_cur->char_at( ndot );
if( n == '\n' )
break;
if( n == '\t' )
col = ((col - 1) / bf_cur->b_mode.md_tabsize + 1) * bf_cur->b_mode.md_tabsize + 1;
else
if( control_character( n ) )
col += ctl_arrow != 0 ?
(term_deccrt != 0
&& (n == ctl('k')
|| n == ctl('l')
|| n == '\r'
|| n == '\033') ) ?
1
:
2
:
4;
else
col++;
ndot++;
}
set_dot( ndot );
dot_col = col;
col_valid = 1;
}
std::vector <double> evalS(
std::vector <double> geom,
std::vector <double> x,
std::vector <double> dx,
int param)
{
std::vector <double> S(nx + 1);
if(param == 0)
{
S[0] = 1.0;
S[nx] = 1.0;
for(int Si = 1; Si < nx; Si++)
{
S[Si] = geom[Si - 1];
}
}
else if(param == 1)
{
S = sinParam(geom, x, dx);\
}
else if(param == 2)
{
std::vector <double> ctl(nctl);
for(int ictl = 1; ictl < nctl - 1; ictl++)
{
ctl[ictl] = geom[ictl - 1];
}
ctl[0] = 1;
ctl[nctl - 1] = 1;
S = evalSpline(ctl, x, dx);
}
return S;
}
HRESULT
AccessibleHandler::ReadHandlerPayload(IStream* aStream, REFIID aIid)
{
if (!aStream) {
return E_INVALIDARG;
}
mscom::StructFromStream deserializer(aStream);
if (!deserializer) {
return E_FAIL;
}
if (deserializer.IsEmpty()) {
return S_FALSE;
}
if (!deserializer.Read(&mCachedData, &IA2Payload_Decode)) {
return E_FAIL;
}
if (!mCachedData.mGeckoBackChannel) {
return S_OK;
}
RefPtr<AccessibleHandlerControl> ctl(gControlFactory.GetOrCreateSingleton());
if (!ctl) {
return E_OUTOFMEMORY;
}
return ctl->Register(WrapNotNull(mCachedData.mGeckoBackChannel));
}
static int ShowAnnotateDialog(const QString& fileName)
{
KConfig* config = new KConfig("cervisiapartrc");
AnnotateDialog* dlg = new AnnotateDialog(*config);
kapp->setMainWidget(dlg);
// get directory for file
const QFileInfo fi(fileName);
QString directory = fi.dirPath(true);
// start the cvs DCOP service
CvsService_stub* cvsService = StartDCOPService(directory);
AnnotateController ctl(dlg, cvsService);
ctl.showDialog(fi.fileName());
int result = kapp->exec();
// stop the cvs DCOP service
cvsService->quit();
delete cvsService;
delete config;
return result;
}
LRESULT CDialogThumbs::OnInitDialog( UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled )
{
dc_memory_ = CreateCompatibleDC(NULL);
WTL::CButton ctl(GetDlgItem(IDC_BTN_THUMB4));
ctl.SetIcon(LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ASIMG_RIGHT)));
return 0;
}
static int ShowAnnotateDialog(const QString& fileName)
{
KConfig* config = new KConfig("cervisiapartrc");
AnnotateDialog* dlg = new AnnotateDialog(*config);
// get directory for file
const QFileInfo fi(fileName);
QString directory = fi.absolutePath();
// start the cvs D-Bus service
OrgKdeCervisiaCvsserviceCvsserviceInterface* cvsService = StartDBusService(directory);
AnnotateController ctl(dlg, cvsService);
ctl.showDialog(fi.fileName());
int result = qApp->exec();
// stop the cvs D-Bus service
cvsService->quit();
delete cvsService;
delete config;
return result;
}
void show_story(display &disp, const std::string &scenario_name,
const config::const_child_itors &story)
{
const int total_segments = count_segments(story);
int segment_count = 0;
config::const_child_iterator itor = story.first;
storyscreen::START_POSITION startpos = storyscreen::START_BEGINNING;
while (itor != story.second)
{
storyscreen::controller ctl(disp, vconfig(*itor, true),
scenario_name, segment_count, total_segments);
storyscreen::STORY_RESULT result = ctl.show(startpos);
switch(result) {
case storyscreen::NEXT:
if(itor != story.second) {
++itor;
++segment_count;
startpos = storyscreen::START_BEGINNING;
}
break;
case storyscreen::BACK:
if(itor != story.first) {
--itor;
--segment_count;
startpos = storyscreen::START_END;
}
break;
case storyscreen::QUIT:
return;
}
}
return;
}
// substitute for wait4() system call
pid_t proctrace_wait(pid_t pid, int *status, int options, struct rusage *rusage) {
#ifdef USE_PTRACE
return wait4(pid, status, options, rusage);
#endif
disable_signal();
if (attached_pid == 0) {
if (pid == -1) {
printf("I don't know what to do in proctrace_wait\n");
exit(1);
}
attached_pid = pid;
}
if (singlestep) {
ctl("step");
singlestep = 0;
} else {
char buf[35];
sprintf(buf, "/proc/%d/wait", attached_pid);
int fd = open(buf, O_WRONLY);
proctrace_wait_mask = ((1ULL << 31) - 1) << 1;
proctrace_wait_mask |= 1ULL;
proctrace_wait_mask |= (1ULL << 40);
// temp hack for strace
proctrace_wait_mask |= (1ULL << 33);
unsigned long long big_endian = 0;
int i;
for (i = 0; i < 8; ++i) {
big_endian |= ((proctrace_wait_mask >> (8*i)) & ((1 << 8)-1)) << (8-i-1)*8;
}
long retvalue = write(fd, &big_endian, sizeof(big_endian));
if (retvalue < 0) {
printf("write to wait failed, fd: %d, buf: %s\n", fd, buf);
}
close(fd);
}
if (status) {
siginfo_t a;
if (proctrace(PTRACE_GETSIGINFO, attached_pid, NULL, (void *)&a) == -1) {
*status = 0;
} else {
if (a.si_signo == 0) a.si_signo = SIGSTOP;
if (a.si_signo > 32) {
*status = (SIGTRAP << 8) | 0177;
} else {
*status = (a.si_signo << 8) | 0177;
}
}
}
return attached_pid;
}
HRESULT
AccessibleHandler::GetClassInfo(ITypeInfo** aOutTypeInfo)
{
RefPtr<AccessibleHandlerControl> ctl(gControlFactory.GetOrCreateSingleton());
if (!ctl) {
return E_OUTOFMEMORY;
}
return ctl->GetHandlerTypeInfo(aOutTypeInfo);
}
void get_settings(unsigned char buffer[], struct settings * kerm) {
kerm->maxl = unchar(buffer[4]);
kerm->time = unchar(buffer[5]);
kerm->npad = unchar(buffer[6]);
kerm->padc = ctl(buffer[7]);
kerm->eol = unchar(buffer[8]);
kerm->qctl = buffer[9];
kerm->qbin = buffer[10];
kerm->chkt = buffer[11];
kerm->rept = buffer[12];
}
void set_settings(unsigned char buffer[], struct settings kerm) {
buffer[4] = tochar(kerm.maxl);
buffer[5] = tochar(kerm.time);
buffer[6] = tochar(kerm.npad);
buffer[7] = ctl(kerm.padc);
buffer[8] = tochar(kerm.eol);
buffer[9] = kerm.qctl;
buffer[10] = kerm.qbin;
buffer[11] = kerm.chkt;
buffer[12] = kerm.rept;
}
void MQFunctions::ctl(MQHCONN conn, MQLONG operation, MQCTLO* options)
{
MQLONG cc = MQCC_OK;
MQLONG rc = MQRC_NONE;
ctl(conn, operation, options, &cc, &rc);
if ( cc != MQCC_OK )
{
throw MQException("", "MQCTL", cc, rc);
}
}
void show_storyscreen(display& disp, const vconfig& story_cfg, const std::string& scenario_name)
{
LOG_NG << "entering storyscreen procedure...\n";
storyscreen::controller ctl(disp, story_cfg, scenario_name);
try {
ctl.show();
} catch(storyscreen::controller::quit const&) {
LOG_NG << "leaving storyscreen for titlescreen...\n";
STUB();
}
LOG_NG << "leaving storyscreen procedure...\n";
}
void link_t::loop() {
timeval_t last_conn = timeval_long_ago;
while(true) {
try {
{
timeval_t now = timeval_current();
interval_t to_sleep = conn_timeout - (timeval_current() - last_conn);
if(to_sleep > interval_zero && bq_sleep(&to_sleep) < 0)
throw exception_sys_t(log::error, errno, "bq_sleep: %m");
}
last_conn = timeval_current();
netaddr_t const &netaddr = remote_netaddr();
int fd = socket(netaddr.sa->sa_family, SOCK_STREAM, 0);
if(fd < 0)
throw exception_sys_t(remote_errors, errno, "socket: %m");
fd_guard_t fd_guard(fd);
bq_fd_setup(fd);
interval_t timeout = conn_timeout;
if(bq_connect(fd, netaddr.sa, netaddr.sa_len, &timeout) < 0)
throw exception_sys_t(remote_errors, errno, "connect: %m");
log_debug("connected");
bq_conn_fd_t conn(fd, ctl(), remote_errors, /* dup = */ true);
proto_instance->proc(conn);
}
catch(exception_sys_t const &ex) {
if(ex.errno_val == ECANCELED)
throw;
ex.log();
}
catch(exception_t const &ex) {
ex.log();
}
}
}
HRESULT
AccessibleHandler::MaybeUpdateCachedData()
{
RefPtr<AccessibleHandlerControl> ctl(gControlFactory.GetOrCreateSingleton());
if (!ctl) {
return E_OUTOFMEMORY;
}
uint32_t gen = ctl->GetCacheGen();
if (gen == mCacheGen) {
return S_OK;
}
if (!mCachedData.mGeckoBackChannel) {
return E_POINTER;
}
return mCachedData.mGeckoBackChannel->Refresh(&mCachedData.mData);
}
AccessibleHandler::AccessibleHandler(IUnknown* aOuter, HRESULT* aResult)
: mscom::Handler(aOuter, aResult)
, mDispatch(nullptr)
, mIA2PassThru(nullptr)
, mServProvPassThru(nullptr)
, mCachedData()
, mCacheGen(0)
{
RefPtr<AccessibleHandlerControl> ctl(gControlFactory.GetOrCreateSingleton());
MOZ_ASSERT(ctl);
if (!ctl) {
if (aResult) {
*aResult = E_UNEXPECTED;
}
return;
}
mCacheGen = ctl->GetCacheGen();
}
void
fgetnum(int r0, int c0, int rn, int cn, int fd)
{
struct ent **pp;
struct ent *p;
int r, c;
for (r = r0; r <= rn; r++) {
for (c = c0, pp = ATBL(tbl, r, c); c <= cn; pp++, c++) {
*line = '\0';
p = *pp;
if (p) {
if (p->cellerror)
sprintf(line, "%s", p->cellerror == CELLERROR ?
"ERROR" : "INVALID");
else if (p->flags & is_valid) {
if (p->format) {
if (*(p->format) == ctl('d')) {
time_t i = (time_t) (p->v);
strftime(line, sizeof(line), (p->format)+1,
localtime(&i));
} else
format(p->format, precision[c], p->v, line,
sizeof(line));
} else
engformat(realfmt[c], fwidth[c], precision[c],
p->v, line, sizeof(line));
}
}
if (c < cn)
strcat(line, "\t");
else
strcat(line, "\n");
write(fd, line, strlen(line));
if (brokenpipe) {
linelim = -1;
return;
}
}
}
linelim = -1;
}
CCEdit::CCEdit(QWidget* parent, CCInfo* n) : QFrame(parent)
{
setupUi(this);
m_info = n;
m_controlcombo->addItem(tr("Off"), -1);
for(int i = 0; i < 128; ++i)
{
QString ctl(QString::number(i)+": ");
m_controlcombo->addItem(ctl.append(midiCtrlName(i)), i);
}
updateValues();
connect(m_learn, SIGNAL(clicked()), this, SLOT(startLearning()));
connect(m_channel, SIGNAL(valueChanged(int)), this, SLOT(channelChanged(int)));
connect(m_controlcombo, SIGNAL(currentIndexChanged(int)), this, SLOT(controlChanged(int)));
connect(m_chkRecord, SIGNAL(toggled(bool)), this, SLOT(recordOnlyChanged(bool)));
connect(m_chkToggle, SIGNAL(toggled(bool)), this, SLOT(toggleChanged(bool)));
connect(m_chkNRPN, SIGNAL(toggled(bool)), this, SLOT(toggleNRPN(bool)));
connect(m_txtMSB, SIGNAL(valueChanged(int)), this, SLOT(msbChanged(int)));
connect(m_txtLSB, SIGNAL(valueChanged(int)), this, SLOT(lsbChanged(int)));
}
void encode_single_char(struct settings kerm, unsigned char buffer[], int *position, unsigned char current_character) {
int k;
k = *position;
if(current_character & 0x80) {
buffer[k++] = kerm.qbin;
current_character &= ~ 0x80;
}
if( ( current_character < 32 ) || ( current_character == 0xff ) ) {
buffer[k++] = kerm.qctl;
current_character = ctl(current_character);
} else if( ( current_character == kerm.qctl ) || ( current_character == kerm.qbin ) || ( current_character == kerm.rept ) ) {
buffer[k++] = kerm.qctl;
}
buffer[k++] = current_character;
*position = k;
}
HRESULT
AccessibleTextTearoff::get_oldText(IA2TextSegment *oldText)
{
if (!oldText) {
return E_INVALIDARG;
}
RefPtr<AccessibleHandlerControl> ctl(gControlFactory.GetSingleton());
MOZ_ASSERT(ctl);
if (!ctl) {
return S_OK;
}
long id;
HRESULT hr = mHandler->get_uniqueID(&id);
if (FAILED(hr)) {
return hr;
}
return ctl->GetOldText(id, WrapNotNull(oldText));
}
void CGetBlackOutDlg::resize() {
CRect cdialog;
GetClientRect(cdialog);
CRect wdialog;
GetWindowRect(&wdialog);
CPoint topleft = wdialog.TopLeft();
CPoint br(topleft.x + mBoard.pwidth()+mBoard.pborder(),
topleft.y + mBoard.pheight()+ 30
+ (mBoard.pper() * 2) + mBoard.pborder());
wdialog.BottomRight() = br;
MoveWindow(wdialog, TRUE);
CWnd *p;
// p = GetDlgItem(IDD_GETBLACKOUT_DIALOG);
p = GetDlgItem(IDC_STATIC1);
CRect staticrect;
p->GetWindowRect(staticrect);
CPoint ctl(0,0);
CPoint cbr(mBoard.pwidth(), mBoard.pheight());
staticrect.TopLeft() = ctl;
staticrect.BottomRight() = cbr;
p->MoveWindow(staticrect, TRUE);
mBoard.mBoardRect = staticrect;
CRect slot(
(mBoard.pborder() * 2) + mBoard.pper(),
(mBoard.pheight()-3),
(mBoard.pborder() * 3) + (mBoard.pper()*3),
(mBoard.pheight())
);
mBoardStatic.setrect(slot);
CRect btr;
UpdateWindow();
}
void decode(struct settings kerm, unsigned char input[], int input_length, unsigned char output[], int *output_length) {
unsigned char times, current_character;
int i, j, k;
k = 0;
for(i = 0; i < input_length; i++) {
if(input[i] == kerm.rept) {
i++;
times = unchar(input[i]);
++i;
} else {
times = 1;
}
if(input[i] == kerm.qbin) {
i++;
current_character = 0x80;
} else {
current_character = 0;
}
if(input[i] == kerm.qctl) {
i++;
if( ( input[i] == kerm.qctl ) || ( input[i] == kerm.qbin ) || ( input[i] == kerm.rept ) )
current_character |= input[i];
else
current_character |= ctl(input[i]);
} else {
current_character |= input[i];
}
for(j = 0; j < times; j++)
output[k++] = current_character;
}
*output_length = k;
}
void doeval (struct enode *e, char *fmt, int row, int col, int fd)
{
double v;
gmyrow = row;
gmycol = col;
v = eval(e);
if (fmt) {
if (*fmt == ctl('d')) {
time_t tv = v;
strftime(line, FBUFLEN, fmt + 1, localtime(&tv));
} else
format(fmt, precision[col], v, line, FBUFLEN);
} else
sprintf(line, "%.15g", v);
strcat(line, "\n");
write(fd, line, strlen(line));
linelim = -1;
efree(e);
if (fmt) scxfree(fmt);
}
HRESULT
AccessibleHandler::ResolveIDispatch()
{
if (mDispatch) {
return S_OK;
}
HRESULT hr;
if (!mDispatchUnk) {
RefPtr<AccessibleHandlerControl> ctl(gControlFactory.GetOrCreateSingleton());
if (!ctl) {
return E_OUTOFMEMORY;
}
RefPtr<ITypeInfo> typeinfo;
hr = ctl->GetHandlerTypeInfo(getter_AddRefs(typeinfo));
if (FAILED(hr)) {
return hr;
}
hr = ::CreateStdDispatch(GetOuter(), static_cast<NEWEST_IA2_INTERFACE*>(this),
typeinfo, getter_AddRefs(mDispatchUnk));
if (FAILED(hr)) {
return hr;
}
}
hr = mDispatchUnk->QueryInterface(IID_IDispatch,
reinterpret_cast<void**>(&mDispatch));
if (SUCCEEDED(hr)) {
// mDispatch is weak (see comments in AccessibleHandler.h)
mDispatch->Release();
}
return hr;
}
void show_story(CVideo& video, const std::string &scenario_name,
const config::const_child_itors &story)
{
events::event_context story_context;
int segment_count = 0;
config::const_child_iterator itor = story.begin();
storyscreen::START_POSITION startpos = storyscreen::START_BEGINNING;
while (itor != story.end())
{
storyscreen::controller ctl(video, vconfig(*itor, true),
scenario_name, segment_count);
storyscreen::STORY_RESULT result = ctl.show(startpos);
switch(result) {
case storyscreen::NEXT:
if(itor != story.end()) {
++itor;
++segment_count;
startpos = storyscreen::START_BEGINNING;
}
break;
case storyscreen::BACK:
if(itor != story.begin()) {
--itor;
--segment_count;
startpos = storyscreen::START_END;
}
break;
case storyscreen::QUIT:
video2::trigger_full_redraw();
return;
}
}
video2::trigger_full_redraw();
return;
}
void do_normalmode(struct block * buf) {
int bs = get_bufsize(buf);
struct ent * e;
switch (buf->value) {
// Movement commands
case 'j':
case OKEY_DOWN:
currow = forw_row(1)->row;
unselect_ranges();
update(TRUE);
break;
case 'k':
case OKEY_UP:
currow = back_row(1)->row;
unselect_ranges();
update(TRUE);
break;
case 'h':
case OKEY_LEFT:
curcol = back_col(1)->col;
unselect_ranges();
update(TRUE);
break;
case 'l':
case OKEY_RIGHT:
curcol = forw_col(1)->col;
unselect_ranges();
update(TRUE);
break;
case '0':
case OKEY_HOME:
curcol = left_limit()->col;
unselect_ranges();
update(TRUE);
break;
case '$':
case OKEY_END:
curcol = right_limit()->col;
unselect_ranges();
update(TRUE);
break;
case '^':
currow = goto_top()->row;
unselect_ranges();
update(TRUE);
break;
case '#':
currow = goto_bottom()->row;
unselect_ranges();
update(TRUE);
break;
// Tick
case '\'':
if (bs != 2) break;
unselect_ranges();
e = tick(buf->pnext->value);
if (row_hidden[e->row]) {
scerror("Cell row is hidden");
break;
}
if (col_hidden[e->col]) {
scerror("Cell column is hidden");
break;
}
currow = e->row;
curcol = e->col;
update(TRUE);
break;
// CTRL j
case ctl('j'):
{
int p, c = curcol, cf = curcol;
if ( (p = is_range_selected()) != -1) {
struct srange * sr = get_range_by_pos(p);
c = sr->tlcol;
cf = sr->brcol;
}
auto_justify(c, cf, DEFWIDTH); // auto justificado de columnas
update(TRUE);
break;
}
// CTRL d
case ctl('d'): // set date format using current locate D_FMT format
{
#ifdef USELOCALE
#include <locale.h>
#include <langinfo.h>
char * loc = NULL;
char * f = NULL;
loc = setlocale(LC_TIME, "");
if (loc != NULL) {
f = nl_langinfo(D_FMT);
} else {
scerror("No locale set. Nothing changed");
}
int p, r = currow, c = curcol, rf = currow, cf = curcol;
if ( (p = is_range_selected()) != -1) {
struct srange * sr = get_range_by_pos(p);
r = sr->tlrow;
c = sr->tlcol;
rf = sr->brrow;
cf = sr->brcol;
}
if (any_locked_cells(r, c, rf, cf)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
dateformat(lookat(r, c), lookat(rf, cf), f);
update(TRUE);
break;
#else
scinfo("Build made without USELOCALE enabled");
#endif
}
// CTRL f
case ctl('f'):
case OKEY_PGDOWN:
{
int n = LINES - RESROW - 1;
if (atoi(get_conf_value("half_page_scroll"))) n = n / 2;
struct ent * e = forw_row(n);
currow = e->row;
unselect_ranges();
scroll_down(n);
update(TRUE);
break;
}
// CTRL b
case ctl('b'):
case OKEY_PGUP:
{
int n = LINES - RESROW - 1;
if (atoi(get_conf_value("half_page_scroll"))) n = n / 2;
currow = back_row(n)->row;
unselect_ranges();
scroll_up(n);
update(TRUE);
break;
}
case 'w':
e = go_forward();
currow = e->row;
curcol = e->col;
unselect_ranges();
update(TRUE);
break;
case 'b':
e = go_backward();
currow = e->row;
curcol = e->col;
unselect_ranges();
update(TRUE);
break;
case '/':
{
char cadena[] = ":int goto ";
int i;
for (i=0; i<strlen(cadena); i++) {
flush_buf(buf);
addto_buf(buf, cadena[i]);
exec_single_cmd(buf);
}
break;
}
case 'H':
currow = vert_top()->row;
unselect_ranges();
update(TRUE);
break;
case 'M':
currow = vert_middle()->row;
unselect_ranges();
update(TRUE);
break;
case 'L':
currow = vert_bottom()->row;
unselect_ranges();
update(TRUE);
break;
case 'G': // goto end
e = go_end();
currow = e->row;
curcol = e->col;
unselect_ranges();
update(TRUE);
break;
// GOTO goto
case ctl('a'):
e = go_home();
curcol = e->col;
currow = e->row;
unselect_ranges();
update(TRUE);
break;
case 'g':
if (buf->pnext->value == '0') { // g0
curcol = go_bol()->col;
} else if (buf->pnext->value == '$') { // g$
curcol = go_eol()->col;
} else if (buf->pnext->value == 'g') { // gg
e = go_home();
curcol = e->col;
currow = e->row;
} else if (buf->pnext->value == 'G') { // gG
e = go_end();
currow = e->row;
curcol = e->col;
} else if (buf->pnext->value == 'M') { // gM
curcol = horiz_middle()->col;
} else { // gA4 (goto cell)
(void) sprintf(interp_line, "goto %s", parse_cell_name(1, buf));
send_to_interp(interp_line);
}
unselect_ranges();
update(TRUE);
break;
// repeat last command
case '.':
copybuffer(lastcmd_buffer, buf); // nose graba en lastcmd_buffer!!
cmd_multiplier = 1;
exec_mult(buf, COMPLETECMDTIMEOUT);
break;
// enter command mode
case ':':
clr_header(input_win, 0);
chg_mode(':');
#ifdef HISTORY_FILE
add(commandline_history, "");
#endif
print_mode(input_win);
wrefresh(input_win);
handle_cursor();
inputline_pos = 0;
break;
// enter visual mode
case 'v':
chg_mode('v');
handle_cursor();
clr_header(input_win, 0);
print_mode(input_win);
wrefresh(input_win);
start_visualmode(currow, curcol, currow, curcol);
break;
// INPUT COMMANDS
case '=':
case '\\':
case '<':
case '>':
if (locked_cell(currow, curcol)) return;
insert_edit_submode = buf->value;
chg_mode(insert_edit_submode);
clr_header(input_win, 0);
print_mode(input_win);
wrefresh(input_win);
inputline_pos = 0;
break;
// EDITION COMMANDS
// edit cell (v)
case 'e':
if (locked_cell(currow, curcol)) return;
clr_header(input_win, 0);
inputline_pos = 0;
if (start_edit_mode(buf, 'v')) show_header(input_win);
break;
// edit cell (s)
case 'E':
if (locked_cell(currow, curcol)) return;
clr_header(input_win, 0);
inputline_pos = 0;
if (start_edit_mode(buf, 's')) show_header(input_win);
else {
scinfo("No string value to edit");
chg_mode('.');
show_celldetails(input_win);
print_mode(input_win);
wrefresh(input_win);
}
break;
// del current cell or range
case 'x':
del_selected_cells();
update(TRUE);
break;
// format col
case 'f':
if (bs != 2) return;
formatcol(buf->pnext->value);
break;
// mark cell or range
case 'm':
if (bs != 2) break;
int p = is_range_selected();
if (p != -1) { // mark range
struct srange * sr = get_range_by_pos(p);
set_range_mark(buf->pnext->value, sr);
} else // mark cell
set_cell_mark(buf->pnext->value, currow, curcol);
modflg++;
break;
// copy
case 'c':
{
if (bs != 2) break;
struct mark * m = get_mark(buf->pnext->value);
if ( m == NULL) return;
// if m represents a range
if ( m->row == -1 && m->col == -1) {
srange * r = m->rng;
yank_area(r->tlrow, r->tlcol, r->brrow, r->brcol, 'a', cmd_multiplier);
if (paste_yanked_ents(0, 'c') == -1) {
scerror("Locked cells encountered. Nothing changed");
break;
}
// if m represents just one cell
} else {
struct ent * p = *ATBL(tbl, get_mark(buf->pnext->value)->row, get_mark(buf->pnext->value)->col);
struct ent * n;
int c1;
#ifdef UNDO
create_undo_action();
#endif
for (c1 = curcol; cmd_multiplier-- && c1 < maxcols; c1++) {
if ((n = * ATBL(tbl, currow, c1))) {
if (n->flags & is_locked)
continue;
if (! p) {
clearent(n);
continue;
}
} else {
if (! p) break;
n = lookat(currow, c1);
}
#ifdef UNDO
copy_to_undostruct(currow, c1, currow, c1, 'd');
#endif
copyent(n, p, currow - get_mark(buf->pnext->value)->row, c1 - get_mark(buf->pnext->value)->col, 0, 0, maxrow, maxcol, 0);
n->row += currow - get_mark(buf->pnext->value)->row;
n->col += c1 - get_mark(buf->pnext->value)->col;
n->flags |= is_changed;
#ifdef UNDO
copy_to_undostruct(currow, c1, currow, c1, 'a');
#endif
}
#ifdef UNDO
end_undo_action();
#endif
}
if (atoi(get_conf_value("autocalc"))) EvalAll();
update(TRUE);
break;
}
// repeat last goto command
case 'n':
go_last();
update(TRUE);
break;
// range lock / unlock / valueize
case 'r':
{
int p, r = currow, c = curcol, rf = currow, cf = curcol;
if ( (p = is_range_selected()) != -1) {
struct srange * sr = get_range_by_pos(p);
r = sr->tlrow;
c = sr->tlcol;
rf = sr->brrow;
cf = sr->brcol;
}
if (buf->pnext->value == 'l') {
lock_cells(lookat(r, c), lookat(rf, cf));
} else if (buf->pnext->value == 'u') {
unlock_cells(lookat(r, c), lookat(rf, cf));
} else if (buf->pnext->value == 'v') {
valueize_area(r, c, rf, cf);
}
update(TRUE);
break;
}
// create range with two marks
case 'R':
if (bs == 3) {
create_range(buf->pnext->value, buf->pnext->pnext->value, NULL, NULL);
update(TRUE);
}
break;
// Zr Zc - Zap col or row - Show col or row - Sr Sc
case 'Z':
case 'S':
{
int rs, r = currow, c = curcol, arg = cmd_multiplier;
struct srange * sr;
if ( (rs = is_range_selected()) != -1) {
sr = get_range_by_pos(rs);
cmd_multiplier = 1;
r = sr->tlrow;
c = sr->tlcol;
arg = buf->pnext->value == 'r' ? sr->brrow - sr->tlrow + 1 : sr->brcol - sr->tlcol + 1;
}
if (buf->value == 'Z' && buf->pnext->value == 'r') {
hide_row(r, arg);
} else if (buf->value == 'Z' && buf->pnext->value == 'c') {
hide_col(c, arg);
} else if (buf->value == 'S' && buf->pnext->value == 'r') {
show_row(r, arg);
} else if (buf->value == 'S' && buf->pnext->value == 'c') {
show_col(c, arg);
}
cmd_multiplier = 0;
update(TRUE);
break;
}
// shift range or cell
case 's':
{
int p, r = currow, c = curcol, rf = currow, cf = curcol;
if ( (p = is_range_selected()) != -1) {
struct srange * sr = get_range_by_pos(p);
r = sr->tlrow;
c = sr->tlcol;
rf = sr->brrow;
cf = sr->brcol;
}
if ( any_locked_cells(r, c, rf, cf) && (buf->pnext->value == 'h' || buf->pnext->value == 'k') ) {
scerror("Locked cells encountered. Nothing changed");
return;
}
#ifdef UNDO
create_undo_action();
#endif
int ic = cmd_multiplier + 1;
switch (buf->pnext->value) {
case 'j':
fix_marks( (rf - r + 1) * cmd_multiplier, 0, r, maxrow, c, cf);
#ifdef UNDO
save_undo_range_shift(cmd_multiplier, 0, r, c, rf + (rf-r+1) * (cmd_multiplier - 1), cf);
#endif
while (ic--) shift_range(ic, 0, r, c, rf, cf);
break;
case 'k':
fix_marks( -(rf - r + 1) * cmd_multiplier, 0, r, maxrow, c, cf);
yank_area(r, c, rf + (rf-r+1) * (cmd_multiplier - 1), cf, 'a', cmd_multiplier); // keep ents in yanklist for sk
#ifdef UNDO
copy_to_undostruct(r, c, rf + (rf-r+1) * (cmd_multiplier - 1), cf, 'd');
save_undo_range_shift(-cmd_multiplier, 0, r, c, rf + (rf-r+1) * (cmd_multiplier - 1), cf);
#endif
while (ic--) shift_range(-ic, 0, r, c, rf, cf);
#ifdef UNDO
copy_to_undostruct(r, c, rf + (rf-r+1) * (cmd_multiplier - 1), cf, 'a');
#endif
break;
case 'h':
fix_marks(0, -(cf - c + 1) * cmd_multiplier, r, rf, c, maxcol);
yank_area(r, c, rf, cf + (cf-c+1) * (cmd_multiplier - 1), 'a', cmd_multiplier); // keep ents in yanklist for sk
#ifdef UNDO
copy_to_undostruct(r, c, rf, cf + (cf-c+1) * (cmd_multiplier - 1), 'd');
save_undo_range_shift(0, -cmd_multiplier, r, c, rf, cf + (cf-c+1) * (cmd_multiplier - 1));
#endif
while (ic--) shift_range(0, -ic, r, c, rf, cf);
#ifdef UNDO
copy_to_undostruct(r, c, rf, cf + (cf-c+1) * (cmd_multiplier - 1), 'a');
#endif
break;
case 'l':
fix_marks(0, (cf - c + 1) * cmd_multiplier, r, rf, c, maxcol);
#ifdef UNDO
save_undo_range_shift(0, cmd_multiplier, r, c, rf, cf + (cf-c+1) * (cmd_multiplier - 1));
#endif
while (ic--) shift_range(0, ic, r, c, rf, cf);
break;
}
#ifdef UNDO
end_undo_action();
#endif
cmd_multiplier = 0;
unselect_ranges();
update(TRUE);
break;
}
// delete row or column, or selected cell or range
case 'd':
{
if (bs != 2) return;
int ic = cmd_multiplier; // orig
if (buf->pnext->value == 'r') {
if (any_locked_cells(currow, 0, currow + cmd_multiplier, maxcol)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
#ifdef UNDO
create_undo_action();
copy_to_undostruct(currow, 0, currow + ic - 1, maxcol, 'd');
save_undo_range_shift(-ic, 0, currow, 0, currow - 1 + ic, maxcol);
#endif
fix_marks(-ic, 0, currow + ic - 1, maxrow, 0, maxcol);
yank_area(currow, 0, currow - 1 + cmd_multiplier, maxcol, 'r', ic);
while (ic--) deleterow();
#ifdef UNDO
copy_to_undostruct(currow, 0, currow - 1 + cmd_multiplier, maxcol, 'a');
end_undo_action();
#endif
if (cmd_multiplier > 0) cmd_multiplier = 0;
} else if (buf->pnext->value == 'c') {
if (any_locked_cells(0, curcol, maxrow, curcol + cmd_multiplier)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
#ifdef UNDO
create_undo_action();
copy_to_undostruct(0, curcol, maxrow, curcol - 1 + ic, 'd');
save_undo_range_shift(0, -ic, 0, curcol, maxrow, curcol - 1 + ic);
#endif
fix_marks(0, -ic, 0, maxrow, curcol - 1 + ic, maxcol);
yank_area(0, curcol, maxrow, curcol + cmd_multiplier - 1, 'c', ic);
while (ic--) deletecol();
#ifdef UNDO
copy_to_undostruct(0, curcol, maxrow, curcol + cmd_multiplier - 1, 'a');
end_undo_action();
#endif
if (cmd_multiplier > 0) cmd_multiplier = 0;
} else if (buf->pnext->value == 'd') {
del_selected_cells();
}
update(TRUE);
break;
}
// insert row or column
case 'i':
{
if (bs != 2) return;
#ifdef UNDO
create_undo_action();
#endif
if (buf->pnext->value == 'r') {
#ifdef UNDO
save_undo_range_shift(1, 0, currow, 0, currow, maxcol);
#endif
fix_marks(1, 0, currow, maxrow, 0, maxcol);
insert_row(0);
} else if (buf->pnext->value == 'c') {
#ifdef UNDO
save_undo_range_shift(0, 1, 0, curcol, maxrow, curcol);
#endif
fix_marks(0, 1, 0, maxrow, curcol, maxcol);
insert_col(0);
}
#ifdef UNDO
end_undo_action();
#endif
update(TRUE);
break;
}
case 'y':
// yank row
if ( bs == 2 && buf->pnext->value == 'r') {
yank_area(currow, 0, currow + cmd_multiplier - 1, maxcol, 'r', cmd_multiplier);
if (cmd_multiplier > 0) cmd_multiplier = 0;
// yank col
} else if ( bs == 2 && buf->pnext->value == 'c') {
yank_area(0, curcol, maxrow, curcol + cmd_multiplier - 1, 'c', cmd_multiplier);
if (cmd_multiplier > 0) cmd_multiplier = 0;
// yank cell
} else if ( bs == 2 && buf->pnext->value == 'y' && is_range_selected() == -1) {
yank_area(currow, curcol, currow, curcol, 'e', cmd_multiplier);
// yank range
} else if ( bs == 1 && is_range_selected() != -1) {
srange * r = get_selected_range();
yank_area(r->tlrow, r->tlcol, r->brrow, r->brcol, 'a', cmd_multiplier);
}
break;
// paste cell below or left
case 'p':
if (paste_yanked_ents(0, 'a') == -1) {
scerror("Locked cells encountered. Nothing changed");
break;
}
update(TRUE);
break;
case 'P':
case 'T':
if (bs != 2) break;
if (buf->pnext->value == 'v' || buf->pnext->value == 'f' || buf->pnext->value == 'c') {
int res = buf->value == 'P' ? paste_yanked_ents(0, buf->pnext->value) : paste_yanked_ents(1, buf->pnext->value); // paste cell above or right
if (res == -1) {
scerror("Locked cells encountered. Nothing changed");
break;
}
update(TRUE);
}
break;
// paste cell above or right
case 't':
if (paste_yanked_ents(1, 'a') == -1) {
scerror("Locked cells encountered. Nothing changed");
break;
}
update(TRUE);
break;
// select inner range - Vir
case 'V':
if (buf->value == 'V' && bs == 3 &&
buf->pnext->value == 'i' && buf->pnext->pnext->value == 'r') {
int tlrow = currow;
int brrow = currow;
int tlcol = curcol;
int brcol = curcol;
int * tlr = &tlrow;
int * brr = &brrow;
int * tlc = &tlcol;
int * brc = &brcol;
select_inner_range(tlr, tlc, brr, brc);
start_visualmode(*tlr, *tlc, *brr, *brc);
}
break;
// autojus
case 'a':
if ( bs != 2 ) break;
if (buf->pnext->value == 'a') {
int p, r = currow, c = curcol, rf = currow, cf = curcol;
if ( (p = is_range_selected()) != -1) {
struct srange * sr = get_range_by_pos(p);
r = sr->tlrow;
c = sr->tlcol;
rf = sr->brrow;
cf = sr->brcol;
}
if (any_locked_cells(r, c, rf, cf)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
char cline [BUFFERSIZE];
sprintf(cline, "autojus %s:", coltoa(c));
sprintf(cline + strlen(cline), "%s", coltoa(cf));
send_to_interp(cline);
update(TRUE);
}
break;
// scroll
case 'z':
if ( bs != 2 ) break;
int scroll = 0;
switch (buf->pnext->value) {
case 'l':
scroll_right(1);
//unselect_ranges();
break;
case 'h':
scroll_left(1);
//unselect_ranges();
break;
case 'H':
scroll = calc_offscr_sc_cols();
if (atoi(get_conf_value("half_page_scroll"))) scroll /= 2;
scroll_left(scroll);
//unselect_ranges();
break;
case 'L':
scroll = calc_offscr_sc_cols();
if (atoi(get_conf_value("half_page_scroll"))) scroll /= 2;
scroll_right(scroll);
//unselect_ranges();
break;
case 'm':
;
int i = 0, c = 0, ancho = rescol;
offscr_sc_cols = 0;
for (i = 0; i < curcol; i++) {
for (c = i; c < curcol; c++) {
if (!col_hidden[c]) ancho += fwidth[c];
if (ancho >= (COLS - rescol)/ 2) {
ancho = rescol;
break;
}
}
if (c == curcol) break;
}
offscr_sc_cols = i;
break;
case 'z':
case '.':
case 't':
case 'b':
if (buf->pnext->value == 'z' || buf->pnext->value == '.')
scroll = currow - offscr_sc_rows + LINES - RESROW - 2 - (LINES - RESROW - 2)/2; // zz
else if (buf->pnext->value == 't')
scroll = currow - offscr_sc_rows + 1;
else if (buf->pnext->value == 'b')
scroll = currow - offscr_sc_rows - LINES + RESROW + 2;
if (scroll > 0)
scroll_down(scroll);
// else if (scroll > offscr_sc_rows)
// scroll_up(-scroll);
else if (scroll < 0)
scroll_up(-scroll);
// else if (offscr_sc_rows > 0)
// scroll_up(offscr_sc_rows);
break;
}
update(TRUE);
break;
// scroll up a line
case ctl('y'):
scroll_up(1);
update(TRUE);
break;
// scroll down a line
case ctl('e'):
scroll_down(1);
update(TRUE);
break;
// undo
case 'u':
#ifdef UNDO
do_undo();
// sync_refs();
EvalAll();
update(TRUE);
break;
#else
scerror("Build was done without UNDO support");
#endif
// redo
case ctl('r'):
#ifdef UNDO
do_redo();
// sync_refs();
EvalAll();
update(TRUE);
break;
#else
scerror("Build was done without UNDO support");
#endif
case '{': // left align
case '}': // right align
case '|': // center align
{
int p, r = currow, c = curcol, rf = currow, cf = curcol;
struct srange * sr;
if ( (p = is_range_selected()) != -1) {
sr = get_range_by_pos(p);
r = sr->tlrow;
c = sr->tlcol;
rf = sr->brrow;
cf = sr->brcol;
}
if (any_locked_cells(r, c, rf, cf)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
#ifdef UNDO
create_undo_action();
#endif
if (buf->value == '{') sprintf(interp_line, "leftjustify %s", v_name(r, c));
else if (buf->value == '}') sprintf(interp_line, "rightjustify %s", v_name(r, c));
else if (buf->value == '|') sprintf(interp_line, "center %s", v_name(r, c));
if (p != -1) sprintf(interp_line + strlen(interp_line), ":%s", v_name(rf, cf));
#ifdef UNDO
copy_to_undostruct(r, c, rf, cf, 'd');
#endif
send_to_interp(interp_line);
#ifdef UNDO
copy_to_undostruct(r, c, rf, cf, 'a');
end_undo_action();
#endif
cmd_multiplier = 0;
update(TRUE);
break;
}
case ctl('l'):
/*
endwin();
start_screen();
clearok(stdscr, TRUE);
update(TRUE);
flushinp();
show_header(input_win);
show_celldetails(input_win);
wrefresh(input_win);
update(TRUE);
*/
winchg();
break;
case '@':
EvalAll();
update(TRUE);
break;
// increase or decrease numeric value of cell or range
case '-':
case '+':
{
int r, c, tlrow = currow, tlcol = curcol, brrow = currow, brcol = curcol;
if ( is_range_selected() != -1 ) {
struct srange * sr = get_selected_range();
tlrow = sr->tlrow;
tlcol = sr->tlcol;
brrow = sr->brrow;
brcol = sr->brcol;
}
if (any_locked_cells(tlrow, tlcol, brrow, brcol)) {
scerror("Locked cells encountered. Nothing changed");
return;
}
if (atoi(get_conf_value("numeric")) == 1) goto numeric;
struct ent * p;
#ifdef UNDO
create_undo_action();
#endif
int arg = cmd_multiplier;
int mf = modflg; // keep original modflg
for (r = tlrow; r <= brrow; r++) {
for (c = tlcol; c <= brcol; c++) {
p = *ATBL(tbl, r, c);
if ( ! p ) {
continue;
} else if (p->expr && !(p->flags & is_strexpr)) {
//scerror("Can't increment / decrement a formula");
continue;
} else if (p->flags & is_valid) {
#ifdef UNDO
copy_to_undostruct(r, c, r, c, 'd');
#endif
p->v += buf->value == '+' ? (double) arg : - 1 * (double) arg;
#ifdef UNDO
copy_to_undostruct(r, c, r, c, 'a');
#endif
if (mf == modflg) modflg++; // increase just one time
}
}
}
#ifdef UNDO
end_undo_action();
#endif
if (atoi(get_conf_value("autocalc"))) EvalAll();
cmd_multiplier = 0;
update(TRUE);
}
break;
// input of numbers
default:
numeric:
if ( (isdigit(buf->value) || buf->value == '-' || buf->value == '+') &&
atoi(get_conf_value("numeric")) ) {
insert_edit_submode='=';
chg_mode(insert_edit_submode);
inputline_pos = 0;
ins_in_line(buf->value);
show_header(input_win);
}
}
return;
}
static int traceme() {
// may not work!
attached_pid = getpid();
ctl("stop");
return 0;
}
char keyarea[N_KEY*30];
char *tgetstr();
char *getenv();
char *ks;
char ks_buf[20];
char *ke;
char ke_buf[20];
#ifdef TIOCSLTC
struct ltchars old_chars, new_chars;
#endif
char dont_use[] = {
ctl('['), ctl('a'), ctl('b'), ctl('c'), ctl('e'), ctl('f'), ctl('g'),
ctl('h'), ctl('i'), ctl('j'), ctl('l'), ctl('m'), ctl('n'), ctl('p'),
ctl('q'), ctl('r'), ctl('s'), ctl('t'), ctl('u'), ctl('v'), ctl('w'),
ctl('x'), ctl('z'), 0
};
void
charout(int c)
{
(void)putchar(c);
}
void
initkbd()
{
register struct key_map *kp;
