summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--core/apps/embeddedkonsole/TEHistory.cpp2
-rw-r--r--core/apps/embeddedkonsole/TEScreen.cpp2
-rw-r--r--core/apps/embeddedkonsole/TEWidget.cpp4
-rw-r--r--core/apps/embeddedkonsole/commandeditdialog.cpp2
-rw-r--r--core/apps/embeddedkonsole/konsole.cpp31
5 files changed, 21 insertions, 20 deletions
diff --git a/core/apps/embeddedkonsole/TEHistory.cpp b/core/apps/embeddedkonsole/TEHistory.cpp
index 504cd13..2417af1 100644
--- a/core/apps/embeddedkonsole/TEHistory.cpp
+++ b/core/apps/embeddedkonsole/TEHistory.cpp
@@ -1,230 +1,230 @@
/* -------------------------------------------------------------------------- */
/* */
/* [TEHistory.C] History Buffer */
/* */
/* -------------------------------------------------------------------------- */
/* */
/* Copyright (c) 1997,1998 by Lars Doelle <lars.doelle@on-line.de> */
/* */
/* This file is part of Qkonsole - an X terminal for KDE */
/* */
/* -------------------------------------------------------------------------- */
/* */
/* Ported Qkonsole to Qt/Embedded */
/* */
/* Copyright (C) 2000 by John Ryland <jryland@trolltech.com> */
/* */
/* -------------------------------------------------------------------------- */
#include "TEHistory.h"
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <qpe/config.h>
#define HERE printf("%s(%d): here\n",__FILE__,__LINE__)
/*
An arbitrary long scroll.
One can modify the scroll only by adding either cells
or newlines, but access it randomly.
The model is that of an arbitrary wide typewriter scroll
in that the scroll is a serie of lines and each line is
a serie of cells with no overwriting permitted.
The implementation provides arbitrary length and numbers
of cells and line/column indexed read access to the scroll
at constant costs.
*/
HistoryScroll::HistoryScroll()
{
m_lines = NULL;
m_max_lines = 0;
m_cells = NULL;
m_max_cells = 0;
m_num_lines = 0;
m_first_line = 0;
m_last_cell = 0;
m_start_line = 0;
}
HistoryScroll::~HistoryScroll()
{
setSize(0,0);
}
void HistoryScroll::setSize(int lines, int cells)
{
// could try to preserve the existing data...
// printf("setSize(%d,%d)\n", lines, cells);
if (m_lines) {
delete m_lines;
m_lines = NULL;
}
if (m_cells) {
delete m_cells;
m_cells = NULL;
}
m_max_lines = m_max_cells = 0;
if (lines > 0 && cells > 0) {
m_max_lines = lines;
m_lines = new int[m_max_lines];
m_lines[0] = 0;
m_max_cells = cells;
m_cells = new ca[m_max_cells];
}
m_first_line = 0;
m_num_lines = 0;
m_last_cell = 0;
m_start_line = 0;
}
void HistoryScroll::setScroll(bool on)
{
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("History");
// printf("setScroll(%d)\n", on);
if (on) {
int lines = cfg.readNumEntry("history_lines",300);
int avg_line = cfg.readNumEntry("avg_line_length",60);
int cells = lines * avg_line;
setSize(lines,cells);
} else {
setSize(0,0);
}
}
bool HistoryScroll::hasScroll()
{
return (m_max_lines > 0);
}
int HistoryScroll::getLines()
{
return(m_num_lines);
}
int HistoryScroll::getLineLen(int lineno)
{
if (!hasScroll()) return 0;
if (lineno >= m_num_lines) {
// printf("getLineLen(%d) out of range %d\n", lineno, m_num_lines);
return(0);
}
int len = startOfLine(lineno+1) - startOfLine(lineno);
if (len < 0) {
len += m_max_cells;
}
// printf("getLineLen(%d) = %d\n", lineno, len);
return(len);
}
int HistoryScroll::startOfLine(int lineno)
{
// printf("startOfLine(%d) =", lineno);
if (!hasScroll()) return 0;
assert(lineno >= 0 && lineno <= m_num_lines);
if (lineno < m_num_lines) {
int index = lineno + m_first_line;
if (index >= m_max_lines)
index -= m_max_lines;
// printf("%d\n", m_lines[index]);
return(m_lines[index]);
} else {
// printf("last %d\n", m_last_cell);
return(m_last_cell);
}
}
void HistoryScroll::getCells(int lineno, int colno, int count, ca *res)
{
// printf("getCells(%d,%d,%d) num_lines=%d\n", lineno, colno, count, m_num_lines);
assert(hasScroll());
assert(lineno >= 0 && lineno < m_num_lines);
int index = lineno + m_first_line;
if (index >= m_max_lines)
index -= m_max_lines;
assert(index >= 0 && index < m_max_lines);
index = m_lines[index] + colno;
assert(index >= 0 && index < m_max_cells);
while(count-- > 0) {
*res++ = m_cells[index];
if (++index >= m_max_cells) {
index = 0;
}
}
}
void HistoryScroll::addCells(ca *text, int count)
{
if (!hasScroll()) return;
int start_cell = m_last_cell;
// printf("addCells count=%d start=%d first_line=%d first_cell=%d lines=%d\n",
// count, start_cell, m_first_line, m_lines[m_first_line], m_num_lines);
if (count <= 0) {
return;
}
while(count-- > 0) {
assert (m_last_cell >= 0 && m_last_cell < m_max_cells );
m_cells[m_last_cell] = *text++;
if (++m_last_cell >= m_max_cells) {
m_last_cell = 0;
}
}
if (m_num_lines > 1) {
if (m_last_cell > start_cell) {
while(m_num_lines > 0
&& m_lines[m_first_line] >= start_cell
&& m_lines[m_first_line] < m_last_cell) {
// printf("A remove %d>%d && %d<%d first_line=%d num_lines=%d\n",
// m_lines[m_first_line], start_cell, m_lines[m_first_line], m_last_cell,
// m_first_line, m_num_lines);
if (++m_first_line >= m_max_lines) {
m_first_line = 0;
}
m_num_lines--;
}
} else {
while(m_num_lines > 0
&& (m_lines[m_first_line] >= start_cell
|| m_lines[m_first_line] < m_last_cell)) {
// printf("B remove %d>%d || %d<%d first_line=%d num_lines=%d\n",
// m_lines[m_first_line], start_cell, m_lines[m_first_line], m_last_cell,
// m_first_line, m_num_lines);
if (++m_first_line >= m_max_lines) {
m_first_line = 0;
}
m_num_lines--;
}
}
}
}
void HistoryScroll::addLine()
{
if (!hasScroll()) return;
int index = m_first_line + m_num_lines;
if (index >= m_max_lines) {
index -= m_max_lines;
}
// printf("addLine line=%d cell=%d\n", index, m_last_cell);
assert(index >= 0 && index < m_max_lines);
m_lines[index] = m_start_line;
m_start_line = m_last_cell;
if (m_num_lines >= m_max_lines) {
if (++m_first_line >= m_num_lines) {
m_first_line = 0;
}
} else {
m_num_lines++;
}
}
diff --git a/core/apps/embeddedkonsole/TEScreen.cpp b/core/apps/embeddedkonsole/TEScreen.cpp
index 4ebc28e..3dbcec2 100644
--- a/core/apps/embeddedkonsole/TEScreen.cpp
+++ b/core/apps/embeddedkonsole/TEScreen.cpp
@@ -309,513 +309,513 @@ void TEScreen::setMode(int m)
{
currParm.mode[m] = TRUE;
switch(m)
{
case MODE_Origin : cuX = 0; cuY = tmargin; break; //FIXME: home
}
}
/*! Reset a specific mode. */
void TEScreen::resetMode(int m)
{
currParm.mode[m] = FALSE;
switch(m)
{
case MODE_Origin : cuX = 0; cuY = 0; break; //FIXME: home
}
}
/*! Save a specific mode. */
void TEScreen::saveMode(int m)
{
saveParm.mode[m] = currParm.mode[m];
}
/*! Restore a specific mode. */
void TEScreen::restoreMode(int m)
{
currParm.mode[m] = saveParm.mode[m];
}
//NOTE: this is a helper function
/*! Return the setting a specific mode. */
BOOL TEScreen::getMode(int m)
{
return currParm.mode[m];
}
/*! Save the cursor position and the rendition attribute settings. */
void TEScreen::saveCursor()
{
sa_cuX = cuX;
sa_cuY = cuY;
sa_cu_re = cu_re;
sa_cu_fg = cu_fg;
sa_cu_bg = cu_bg;
}
/*! Restore the cursor position and the rendition attribute settings. */
void TEScreen::restoreCursor()
{
cuX = QMIN(sa_cuX,columns-1);
cuY = QMIN(sa_cuY,lines-1);
cu_re = sa_cu_re;
cu_fg = sa_cu_fg;
cu_bg = sa_cu_bg;
effectiveRendition();
}
/* ------------------------------------------------------------------------- */
/* */
/* Screen Operations */
/* */
/* ------------------------------------------------------------------------- */
/*! Assing a new size to the screen.
The topmost left position is maintained, while lower lines
or right hand side columns might be removed or filled with
spaces to fit the new size.
The region setting is reset to the whole screen and the
tab positions reinitialized.
*/
void TEScreen::resizeImage(int new_lines, int new_columns)
{
if (cuY > new_lines-1) {
// attempt to preserve focus and lines
bmargin = lines-1; //FIXME: margin lost
for (int i = 0; i < cuY-(new_lines-1); i++) {
addHistLine(); scrollUp(horzCursor,1);
}
}
// make new image
ca* newimg = (ca*)malloc( new_lines * new_columns * sizeof( ca));
clearSelection();
// clear new image
for (int y = 0; y < new_lines; y++)
for (int x = 0; x < new_columns; x++) {
newimg[y*new_columns+x].c = ' ';
newimg[y*new_columns+x].f = DEFAULT_FORE_COLOR;
newimg[y*new_columns+x].b = DEFAULT_BACK_COLOR;
newimg[y*new_columns+x].r = DEFAULT_RENDITION;
}
int cpy_lines = QMIN(new_lines, lines);
int cpy_columns = QMIN(new_columns,columns);
// copy to new image
for (int y = 0; y < cpy_lines; y++)
for (int x = 0; x < cpy_columns; x++) {
newimg[y*new_columns+x].c = image[loc(x,y)].c;
newimg[y*new_columns+x].f = image[loc(x,y)].f;
newimg[y*new_columns+x].b = image[loc(x,y)].b;
newimg[y*new_columns+x].r = image[loc(x,y)].r;
}
free(image);
image = newimg;
lines = new_lines;
columns = new_columns;
cuX = QMIN(cuX,columns-1);
cuY = QMIN(cuY,lines-1);
// FIXME: try to keep values, evtl.
tmargin=0;
bmargin=lines-1;
initTabStops();
clearSelection();
}
/*
Clarifying rendition here and in TEWidget.
currently, TEWidget's color table is
0 1 2 .. 9 10 .. 17
dft_fg, dft_bg, dim 0..7, intensive 0..7
cu_fg, cu_bg contain values 0..8;
- 0 = default color
- 1..8 = ansi specified color
re_fg, re_bg contain values 0..17
due to the TEWidget's color table
rendition attributes are
attr widget screen
-------------- ------ ------
RE_UNDERLINE XX XX affects foreground only
RE_BLINK XX XX affects foreground only
RE_BOLD XX XX affects foreground only
RE_REVERSE -- XX
RE_TRANSPARENT XX -- affects background only
RE_INTENSIVE XX -- affects foreground only
Note that RE_BOLD is used in both widget
and screen rendition. Since xterm/vt102
is to poor to distinguish between bold
(which is a font attribute) and intensive
(which is a color attribute), we translate
this and RE_BOLD in falls eventually appart
into RE_BOLD and RE_INTENSIVE.
*/
void TEScreen::reverseRendition(ca* p)
{ UINT8 f = p->f; UINT8 b = p->b;
p->f = b; p->b = f; //p->r &= ~RE_TRANSPARENT;
}
void TEScreen::effectiveRendition()
// calculate rendition
{
ef_re = cu_re & (RE_UNDERLINE | RE_BLINK);
if (cu_re & RE_REVERSE)
{
ef_fg = cu_bg;
ef_bg = cu_fg;
}
else
{
ef_fg = cu_fg;
ef_bg = cu_bg;
}
if (cu_re & RE_BOLD)
{
if (ef_fg < BASE_COLORS)
ef_fg += BASE_COLORS;
else
ef_fg -= BASE_COLORS;
}
}
/*!
returns the image.
Get the size of the image by \sa getLines and \sa getColumns.
NOTE that the image returned by this function must later be
freed.
*/
ca* TEScreen::getCookedImage()
{
int x,y;
ca* merged = (ca*)malloc(lines*columns*sizeof(ca));
ca dft(' ',DEFAULT_FORE_COLOR,DEFAULT_BACK_COLOR,DEFAULT_RENDITION);
if (histCursor > hist.getLines()) {
histCursor = hist.getLines();
}
for (y = 0; (y < lines) && (y < (hist.getLines()-histCursor)); y++)
{
int len = QMIN(columns,hist.getLineLen(y+histCursor));
int yp = y*columns;
int yq = (y+histCursor)*columns;
hist.getCells(y+histCursor,0,len,merged+yp);
for (x = len; x < columns; x++) merged[yp+x] = dft;
for (x = 0; x < columns; x++)
{ int p=x + yp; int q=x + yq;
if ( ( q >= sel_TL ) && ( q <= sel_BR ) )
reverseRendition(&merged[p]); // for selection
}
}
if (lines >= hist.getLines()-histCursor)
{
for (y = (hist.getLines()-histCursor); y < lines ; y++)
{
int yp = y*columns;
int yq = (y+histCursor)*columns;
int yr = (y-hist.getLines()+histCursor)*columns;
for (x = 0; x < columns; x++)
{ int p = x + yp; int q = x + yq; int r = x + yr;
merged[p] = image[r];
if ( q >= sel_TL && q <= sel_BR )
reverseRendition(&merged[p]); // for selection
}
}
}
// evtl. inverse display
if (getMode(MODE_Screen))
{ int i,n = lines*columns;
for (i = 0; i < n; i++)
reverseRendition(&merged[i]); // for reverse display
}
if (getMode(MODE_Cursor) && (cuY+(hist.getLines()-histCursor) < lines)) // cursor visible
reverseRendition(&merged[loc(cuX,cuY+(hist.getLines()-histCursor))]);
return merged;
}
/*!
*/
void TEScreen::reset()
{
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("ScrollBar");
if( !cfg.readBoolEntry("HorzScroll",0) )
setMode(MODE_Wrap ); saveMode(MODE_Wrap ); // wrap at end of margin
resetMode(MODE_Origin); saveMode(MODE_Origin); // position refere to [1,1]
resetMode(MODE_Insert); saveMode(MODE_Insert); // overstroke
setMode(MODE_Cursor); // cursor visible
resetMode(MODE_Screen); // screen not inverse
resetMode(MODE_NewLine);
tmargin=0;
bmargin=lines-1;
setDefaultRendition();
saveCursor();
clear();
}
/*! Clear the entire screen and home the cursor.
*/
void TEScreen::clear()
{
clearEntireScreen();
home();
}
/*! Moves the cursor left one column.
*/
void TEScreen::BackSpace()
{
cuX = QMAX(0,cuX-1);
if (BS_CLEARS) image[loc(cuX,cuY)].c = ' ';
}
/*!
*/
void TEScreen::Tabulate()
{
// note that TAB is a format effector (does not write ' ');
cursorRight(1); while(cuX < columns-1 && !tabstops[cuX]) cursorRight(1);
}
void TEScreen::clearTabStops()
{
for (int i = 0; i < columns; i++) tabstops[i-1] = FALSE;
}
void TEScreen::changeTabStop(bool set)
{
if (cuX >= columns) return;
tabstops[cuX] = set;
}
void TEScreen::initTabStops()
{
if (tabstops) free(tabstops);
tabstops = (bool*)malloc(columns*sizeof(bool));
// Arrg! The 1st tabstop has to be one longer than the other.
// i.e. the kids start counting from 0 instead of 1.
// Other programs might behave correctly. Be aware.
for (int i = 0; i < columns; i++) tabstops[i] = (i%8 == 0 && i != 0);
}
/*!
This behaves either as IND (Screen::Index) or as NEL (Screen::NextLine)
depending on the NewLine Mode (LNM). This mode also
affects the key sequence returned for newline ([CR]LF).
*/
void TEScreen::NewLine()
{
if (getMode(MODE_NewLine)) Return();
index();
}
/*! put `c' literally onto the screen at the current cursor position.
VT100 uses the convention to produce an automatic newline (am)
with the *first* character that would fall onto the next line (xenl).
*/
void TEScreen::checkSelection(int from, int to)
{
if (sel_begin == -1) return;
int scr_TL = loc(0, hist.getLines());
//Clear entire selection if it overlaps region [from, to]
if ( (sel_BR > (from+scr_TL) )&&(sel_TL < (to+scr_TL)) )
{
clearSelection();
}
}
void TEScreen::ShowCharacter(unsigned short c)
{
// Note that VT100 does wrapping BEFORE putting the character.
// This has impact on the assumption of valid cursor positions.
// We indicate the fact that a newline has to be triggered by
// putting the cursor one right to the last column of the screen.
if (cuX >= columns)
{
if (getMode(MODE_Wrap)) NextLine(); else cuX = columns - 1;
// comment out for no wrap
}
if (getMode(MODE_Insert)) insertChars(1);
int i = loc( cuX, cuY);
checkSelection(i, i); // check if selection is still valid.
image[i].c = c;
image[i].f = ef_fg;
image[i].b = ef_bg;
image[i].r = ef_re;
cuX += 1;
}
// Region commands -------------------------------------------------------------
/*! scroll up `n' lines within current region.
The `n' new lines are cleared.
\sa setRegion \sa scrollDown
*/
void TEScreen::scrollUp(int from, int n)
{
if (n <= 0 || from + n > bmargin) return;
//FIXME: make sure `tmargin', `bmargin', `from', `n' is in bounds.
moveImage( loc( 0, from), loc( 0, from + n), loc( columns - 1, bmargin));
clearImage( loc( 0, bmargin - n + 1), loc( columns - 1, bmargin), ' ');
}
/*! scroll down `n' lines within current region.
The `n' new lines are cleared.
\sa setRegion \sa scrollUp
*/
void TEScreen::scrollDown(int from, int n)
{
//FIXME: make sure `tmargin', `bmargin', `from', `n' is in bounds.
if (n <= 0) return;
if (from > bmargin) return;
if (from + n > bmargin) n = bmargin - from;
moveImage( loc(0,from+n), loc(0,from), loc(columns-1,bmargin-n));
clearImage(loc(0,from),loc(columns-1,from+n-1),' ');
}
/*! position the cursor to a specific line and column. */
void TEScreen::setCursorYX(int y, int x)
{
setCursorY(y); setCursorX(x);
}
/*! Set the cursor to x-th line. */
void TEScreen::setCursorX(int x)
{
if (x == 0) x = 1; // Default
x -= 1; // Adjust
cuX = QMAX(0,QMIN(columns-1, x));
}
/*! Set the cursor to y-th line. */
void TEScreen::setCursorY(int y)
{
if (y == 0) y = 1; // Default
y -= 1; // Adjust
cuY = QMAX(0,QMIN(lines -1, y + (getMode(MODE_Origin) ? tmargin : 0) ));
}
/*! set cursor to the `left upper' corner of the screen (1,1).
*/
void TEScreen::home()
{
cuX = 0;
cuY = 0;
}
/*! set cursor to the begin of the current line.
*/
void TEScreen::Return()
{
cuX = 0;
}
/*! returns the current cursor columns.
*/
int TEScreen::getCursorX()
{
return cuX;
}
/*! returns the current cursor line.
*/
int TEScreen::getCursorY()
{
return cuY;
}
// Erasing ---------------------------------------------------------------------
/*! \section Erasing
This group of operations erase parts of the screen contents by filling
it with spaces colored due to the current rendition settings.
Althought the cursor position is involved in most of these operations,
it is never modified by them.
*/
/*! fill screen between (including) `loca' and `loce' with spaces.
This is an internal helper functions. The parameter types are internal
addresses of within the screen image and make use of the way how the
screen matrix is mapped to the image vector.
*/
void TEScreen::clearImage(int loca, int loce, char c)
{ int i;
int scr_TL=loc(0,hist.getLines());
//FIXME: check positions
//Clear entire selection if it overlaps region to be moved...
if ( (sel_BR > (loca+scr_TL) )&&(sel_TL < (loce+scr_TL)) )
{
clearSelection();
}
for (i = loca; i <= loce; i++)
{
image[i].c = c;
image[i].f = ef_fg; //DEFAULT_FORE_COLOR; //FIXME: xterm and linux/ansi
image[i].b = ef_bg; //DEFAULT_BACK_COLOR; // many have different
image[i].r = ef_re; //DEFAULT_RENDITION; // ideas here.
}
}
/*! move image between (including) `loca' and `loce' to 'dst'.
diff --git a/core/apps/embeddedkonsole/TEWidget.cpp b/core/apps/embeddedkonsole/TEWidget.cpp
index 98c3cdf..2e3e0f5 100644
--- a/core/apps/embeddedkonsole/TEWidget.cpp
+++ b/core/apps/embeddedkonsole/TEWidget.cpp
@@ -53,513 +53,513 @@
#include <qpe/config.h>
#include <qpe/resource.h>
#include <qpe/sound.h>
#if !(QT_NO_COP)
#include <qpe/qcopenvelope_qws.h>
#endif
#include <qcursor.h>
#include <qregexp.h>
#include <qpainter.h>
#include <qclipboard.h>
#include <qstyle.h>
#include <qfile.h>
#include <qdragobject.h>
#include <qnamespace.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <signal.h>
#include <assert.h>
// #include "TEWidget.moc"
//#include <kapp.h>
//#include <kcursor.h>
//#include <kurl.h>
//#include <kdebug.h>
//#include <klocale.h>
#define HERE printf("%s(%d): %s\n",__FILE__,__LINE__,__FUNCTION__)
#define HCNT(Name) // { static int cnt = 1; printf("%s(%d): %s %d\n",__FILE__,__LINE__,Name,cnt++); }
#define loc(X,Y) ((Y)*columns+(X))
//FIXME: the rim should normally be 1, 0 only when running in full screen mode.
#define rimX 0 // left/right rim width
#define rimY 0 // top/bottom rim high
#define SCRWIDTH 16 // width of the scrollbar
#define yMouseScroll 1
// scroll increment used when dragging selection at top/bottom of window.
/* ------------------------------------------------------------------------- */
/* */
/* Colors */
/* */
/* ------------------------------------------------------------------------- */
//FIXME: the default color table is in session.C now.
// We need a way to get rid of this one, here.
static const ColorEntry base_color_table[TABLE_COLORS] =
// The following are almost IBM standard color codes, with some slight
// gamma correction for the dim colors to compensate for bright X screens.
// It contains the 8 ansiterm/xterm colors in 2 intensities.
{
// Fixme: could add faint colors here, also.
// normal
ColorEntry(QColor(0x00,0x00,0x00), 0, 0 ), ColorEntry( QColor(0xB2,0xB2,0xB2), 1, 0 ), // Dfore, Dback
ColorEntry(QColor(0x00,0x00,0x00), 0, 0 ), ColorEntry( QColor(0xB2,0x18,0x18), 0, 0 ), // Black, Red
ColorEntry(QColor(0x18,0xB2,0x18), 0, 0 ), ColorEntry( QColor(0xB2,0x68,0x18), 0, 0 ), // Green, Yellow
ColorEntry(QColor(0x18,0x18,0xB2), 0, 0 ), ColorEntry( QColor(0xB2,0x18,0xB2), 0, 0 ), // Blue, Magenta
ColorEntry(QColor(0x18,0xB2,0xB2), 0, 0 ), ColorEntry( QColor(0xB2,0xB2,0xB2), 0, 0 ), // Cyan, White
// intensiv
ColorEntry(QColor(0x00,0x00,0x00), 0, 1 ), ColorEntry( QColor(0xFF,0xFF,0xFF), 1, 0 ),
ColorEntry(QColor(0x68,0x68,0x68), 0, 0 ), ColorEntry( QColor(0xFF,0x54,0x54), 0, 0 ),
ColorEntry(QColor(0x54,0xFF,0x54), 0, 0 ), ColorEntry( QColor(0xFF,0xFF,0x54), 0, 0 ),
ColorEntry(QColor(0x54,0x54,0xFF), 0, 0 ), ColorEntry( QColor(0xB2,0x18,0xB2), 0, 0 ),
ColorEntry(QColor(0x54,0xFF,0xFF), 0, 0 ), ColorEntry( QColor(0xFF,0xFF,0xFF), 0, 0 )
};
/* Note that we use ANSI color order (bgr), while IBMPC color order is (rgb)
Code 0 1 2 3 4 5 6 7
----------- ------- ------- ------- ------- ------- ------- ------- -------
ANSI (bgr) Black Red Green Yellow Blue Magenta Cyan White
IBMPC (rgb) Black Blue Green Cyan Red Magenta Yellow White
*/
QColor TEWidget::getDefaultBackColor()
{
return color_table[DEFAULT_BACK_COLOR].color;
}
const ColorEntry* TEWidget::getColorTable() const
{
return color_table;
}
const ColorEntry* TEWidget::getdefaultColorTable() const
{
return base_color_table;
}
const QPixmap *TEWidget::backgroundPixmap()
{
static QPixmap *bg = new QPixmap("~/qpim/main/pics/faded_bg.xpm");
const QPixmap *pm = bg;
return pm;
}
void TEWidget::setColorTable(const ColorEntry table[])
{
for (int i = 0; i < TABLE_COLORS; i++) color_table[i] = table[i];
const QPixmap* pm = backgroundPixmap();
if (!pm) setBackgroundColor(color_table[DEFAULT_BACK_COLOR].color);
update();
}
//FIXME: add backgroundPixmapChanged.
/* ------------------------------------------------------------------------- */
/* */
/* Font */
/* */
/* ------------------------------------------------------------------------- */
/*
The VT100 has 32 special graphical characters. The usual vt100 extended
xterm fonts have these at 0x00..0x1f.
QT's iso mapping leaves 0x00..0x7f without any changes. But the graphicals
come in here as proper unicode characters.
We treat non-iso10646 fonts as VT100 extended and do the requiered mapping
from unicode to 0x00..0x1f. The remaining translation is then left to the
QCodec.
*/
// assert for i in [0..31] : vt100extended(vt100_graphics[i]) == i.
unsigned short vt100_graphics[32] =
{ // 0/8 1/9 2/10 3/11 4/12 5/13 6/14 7/15
0x0020, 0x25C6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0,
0x00b1, 0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c,
0xF800, 0xF801, 0x2500, 0xF803, 0xF804, 0x251c, 0x2524, 0x2534,
0x252c, 0x2502, 0x2264, 0x2265, 0x03C0, 0x2260, 0x00A3, 0x00b7
};
static QChar vt100extended(QChar c)
{
switch (c.unicode())
{
case 0x25c6 : return 1;
case 0x2592 : return 2;
case 0x2409 : return 3;
case 0x240c : return 4;
case 0x240d : return 5;
case 0x240a : return 6;
case 0x00b0 : return 7;
case 0x00b1 : return 8;
case 0x2424 : return 9;
case 0x240b : return 10;
case 0x2518 : return 11;
case 0x2510 : return 12;
case 0x250c : return 13;
case 0x2514 : return 14;
case 0x253c : return 15;
case 0xf800 : return 16;
case 0xf801 : return 17;
case 0x2500 : return 18;
case 0xf803 : return 19;
case 0xf804 : return 20;
case 0x251c : return 21;
case 0x2524 : return 22;
case 0x2534 : return 23;
case 0x252c : return 24;
case 0x2502 : return 25;
case 0x2264 : return 26;
case 0x2265 : return 27;
case 0x03c0 : return 28;
case 0x2260 : return 29;
case 0x00a3 : return 30;
case 0x00b7 : return 31;
}
return c;
}
static QChar identicalMap(QChar c)
{
return c;
}
void TEWidget::fontChange(const QFont &)
{
QFontMetrics fm(font());
font_h = fm.height();
// font_w = fm.maxWidth();
font_w = fm.width("m");
font_a = fm.ascent();
printf("font h=%d max_width=%d width_m=%d assent=%d\n", font_h,
fm.maxWidth(), font_w, font_a);
//printf("font_h: %d\n",font_h);
//printf("font_w: %d\n",font_w);
//printf("font_a: %d\n",font_a);
//printf("charset: %s\n",QFont::encodingName(font().charSet()).ascii());
//printf("rawname: %s\n",font().rawName().ascii());
fontMap =
#if QT_VERSION < 300
strcmp(QFont::encodingName(font().charSet()).ascii(),"iso10646")
? vt100extended
:
#endif
identicalMap;
propagateSize();
update();
}
void TEWidget::setVTFont(const QFont& f)
{
QFrame::setFont(f);
}
QFont TEWidget::getVTFont() {
return font();
}
void TEWidget::setFont(const QFont &)
{
// ignore font change request if not coming from konsole itself
}
/* ------------------------------------------------------------------------- */
/* */
/* Constructor / Destructor */
/* */
/* ------------------------------------------------------------------------- */
TEWidget::TEWidget(QWidget *parent, const char *name) : QFrame(parent,name)
{
#ifndef QT_NO_CLIPBOARD
cb = QApplication::clipboard();
QObject::connect( (QObject*)cb, SIGNAL(dataChanged()),
this, SLOT(onClearSelection()) );
#endif
scrollbar = new QScrollBar(this);
scrollbar->setCursor( arrowCursor );
connect(scrollbar, SIGNAL(valueChanged(int)), this, SLOT(scrollChanged(int)));
hScrollbar = new QScrollBar(this);
hScrollbar->setCursor( arrowCursor );
hScrollbar->setOrientation(QScrollBar::Horizontal);
// hScrollbar->setMaximumHeight(16);
connect( hScrollbar, SIGNAL(valueChanged(int)), this, SLOT( hScrollChanged(int)));
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("ScrollBar");
switch( cfg.readNumEntry("Position",2)){
case 0:
scrollLoc = SCRNONE;
break;
case 1:
scrollLoc = SCRLEFT;
break;
case 2:
scrollLoc = SCRRIGHT;
break;
};
useHorzScroll=cfg.readBoolEntry("HorzScroll",0);
blinkT = new QTimer(this);
connect(blinkT, SIGNAL(timeout()), this, SLOT(blinkEvent()));
// blinking = FALSE;
blinking = TRUE;
resizing = FALSE;
actSel = 0;
image = 0;
lines = 1;
columns = 1;
font_w = 1;
font_h = 1;
font_a = 1;
word_selection_mode = FALSE;
hposition = 0;
vcolumns = 0;
useBeep = true;
setMouseMarks(TRUE);
setVTFont( QFont("fixed") );
setColorTable(base_color_table); // init color table
qApp->installEventFilter( this ); //FIXME: see below
// KCursor::setAutoHideCursor( this, true );
// Init DnD ////////////////////////////////////////////////////////////////
currentSession = NULL;
// setAcceptDrops(true); // attempt
// m_drop = new QPopupMenu(this);
// m_drop->insertItem( QString("Paste"), 0);
// m_drop->insertItem( QString("cd"), 1);
// connect(m_drop, SIGNAL(activated(int)), SLOT(drop_menu_activated(int)));
// we need focus so that the auto-hide cursor feature works
setFocus();
setFocusPolicy( WheelFocus );
}
//FIXME: make proper destructor
// Here's a start (David)
TEWidget::~TEWidget()
{
qApp->removeEventFilter( this );
if (image) free(image);
}
/* ------------------------------------------------------------------------- */
/* */
/* Display Operations */
/* */
/* ------------------------------------------------------------------------- */
/*!
attributed string draw primitive
*/
void TEWidget::drawAttrStr(QPainter &paint, QRect rect,
QString& str, ca attr, BOOL pm, BOOL clear)
{
if (pm && color_table[attr.b].transparent)
{
paint.setBackgroundMode( TransparentMode );
if (clear) erase(rect);
}
else
{
if (blinking)
paint.fillRect(rect, color_table[attr.b].color);
else
{
paint.setBackgroundMode( OpaqueMode );
paint.setBackgroundColor( color_table[attr.b].color );
}
}
if (color_table[attr.f].bold)
paint.setPen(QColor( 0x8F, 0x00, 0x00 ));
else
paint.setPen(color_table[attr.f].color);
paint.drawText(rect.x(),rect.y()+font_a, str);
if (attr.r & RE_UNDERLINE)
paint.drawLine(rect.left(), rect.y()+font_a+1, rect.right(),rect.y()+font_a+1 );
}
/*!
The image can only be set completely.
The size of the new image may or may not match the size of the widget.
*/
void TEWidget::setImage(const ca* const newimg, int lines, int columns)
{ int y,x,len;
const QPixmap* pm = backgroundPixmap();
QPainter paint;
setUpdatesEnabled(FALSE);
paint.begin( this );
HCNT("setImage");
QPoint tL = contentsRect().topLeft();
int tLx = tL.x();
int tLy = tL.y();
hasBlinker = FALSE;
int cf = -1; // undefined
int cb = -1; // undefined
int cr = -1; // undefined
int lins = QMIN(this->lines, QMAX(0,lines ));
int cols = QMIN(this->columns,QMAX(0,columns));
QChar *disstrU = new QChar[cols];
for (y = 0; y < lins; y++) {
const ca* lcl = &image[y*this->columns];
const ca* const ext = &newimg[y*columns];
if (!resizing) // not while resizing, we're expecting a paintEvent
for (x = 0; x < cols; x++)
{
hasBlinker |= (ext[x].r & RE_BLINK);
if (ext[x] != lcl[x])
{
cr = ext[x].r;
cb = ext[x].b;
if (ext[x].f != cf) cf = ext[x].f;
int lln = cols - x;
disstrU[0] = fontMap(ext[x+0].c);
for (len = 1; len < lln; len++)
{
if (ext[x+len].f != cf || ext[x+len].b != cb || ext[x+len].r != cr ||
ext[x+len] == lcl[x+len] )
break;
disstrU[len] = fontMap(ext[x+len].c);
}
QString unistr(disstrU,len);
drawAttrStr(paint,
QRect(blX+tLx+font_w*x,bY+tLy+font_h*y,font_w*len,font_h),
unistr, ext[x], pm != NULL, true);
x += len - 1;
}
}
// finally, make `image' become `newimg'.
memcpy((void*)lcl,(const void*)ext,cols*sizeof(ca));
}
drawFrame( &paint );
paint.end();
setUpdatesEnabled(TRUE);
if ( hasBlinker && !blinkT->isActive()) blinkT->start(1000); // 1000 ms
if (!hasBlinker && blinkT->isActive()) { blinkT->stop(); blinking = FALSE; }
delete [] disstrU;
}
// paint Event ////////////////////////////////////////////////////
/*!
The difference of this routine vs. the `setImage' is,
that the drawing does not include a difference analysis
between the old and the new image. Instead, the internal
image is used and the painting bound by the PaintEvent box.
*/
void TEWidget::paintEvent( QPaintEvent* pe )
{
//{ static int cnt = 0; printf("paint %d\n",cnt++); }
const QPixmap* pm = backgroundPixmap();
QPainter paint;
setUpdatesEnabled(FALSE);
paint.begin( this );
paint.setBackgroundMode( TransparentMode );
HCNT("paintEvent");
// Note that the actual widget size can be slightly larger
// that the image (the size is truncated towards the smaller
// number of characters in `resizeEvent'. The paint rectangle
// can thus be larger than the image, but less then the size
// of one character.
QRect rect = pe->rect().intersect(contentsRect());
QPoint tL = contentsRect().topLeft();
int tLx = tL.x();
int tLy = tL.y();
int lux = QMIN(columns-1, QMAX(0,(rect.left() - tLx - blX ) / font_w));
int luy = QMIN(lines-1, QMAX(0,(rect.top() - tLy - bY ) / font_h));
int rlx = QMIN(columns-1, QMAX(0,(rect.right() - tLx - blX ) / font_w));
int rly = QMIN(lines-1, QMAX(0,(rect.bottom() - tLy - bY ) / font_h));
/*
printf("paintEvent: %d..%d, %d..%d (%d..%d, %d..%d)\n",lux,rlx,luy,rly,
rect.left(), rect.right(), rect.top(), rect.bottom());
*/
// if (pm != NULL && color_table[image->b].transparent)
// erase(rect);
// BL: I have no idea why we need this, and it breaks the refresh.
QChar *disstrU = new QChar[columns];
for (int y = luy; y <= rly; y++)
for (int x = lux; x <= rlx; x++)
{
int len = 1;
disstrU[0] = fontMap(image[loc(x,y)].c);
int cf = image[loc(x,y)].f;
int cb = image[loc(x,y)].b;
int cr = image[loc(x,y)].r;
while (x+len <= rlx &&
image[loc(x+len,y)].f == cf &&
image[loc(x+len,y)].b == cb &&
image[loc(x+len,y)].r == cr )
{
disstrU[len] = fontMap(image[loc(x+len,y)].c);
len += 1;
}
QString unistr(disstrU,len);
drawAttrStr(paint,
QRect(blX+tLx+font_w*x,bY+tLy+font_h*y,font_w*len,font_h),
unistr, image[loc(x,y)], pm != NULL, false);
x += len - 1;
}
delete [] disstrU;
drawFrame( &paint );
paint.end();
setUpdatesEnabled(TRUE);
}
void TEWidget::blinkEvent()
{
blinking = !blinking;
repaint(FALSE);
}
/* ------------------------------------------------------------------------- */
/* */
/* Resizing */
/* */
/* ------------------------------------------------------------------------- */
void TEWidget::resizeEvent(QResizeEvent* ev)
{
// printf("resize: %d,%d\n",ev->size().width(),ev->size().height());
@@ -974,460 +974,460 @@ void TEWidget::setSelection(const QString& t)
QObject *cb = QApplication::clipboard();
QObject::disconnect( cb, SIGNAL(dataChanged()),
this, SLOT(onClearSelection()) );
QApplication::clipboard()->setText(t);
QObject::connect( cb, SIGNAL(dataChanged()),
this, SLOT(onClearSelection()) );
#endif
}
void TEWidget::onClearSelection()
{
emit clearSelectionSignal();
}
/* ------------------------------------------------------------------------- */
/* */
/* Keyboard */
/* */
/* ------------------------------------------------------------------------- */
//FIXME: an `eventFilter' has been installed instead of a `keyPressEvent'
// due to a bug in `QT' or the ignorance of the author to prevent
// repaint events being emitted to the screen whenever one leaves
// or reenters the screen to/from another application.
//
// Troll says one needs to change focusInEvent() and focusOutEvent(),
// which would also let you have an in-focus cursor and an out-focus
// cursor like xterm does.
// for the auto-hide cursor feature, I added empty focusInEvent() and
// focusOutEvent() so that update() isn't called.
// For auto-hide, we need to get keypress-events, but we only get them when
// we have focus.
void TEWidget::doScroll(int lines)
{
scrollbar->setValue(scrollbar->value()+lines);
}
void TEWidget::doHScroll(int lines) {
hScrollbar->setValue( hScrollbar->value()+lines);
}
bool TEWidget::eventFilter( QObject *obj, QEvent *e )
{
if ( (e->type() == QEvent::Accel ||
e->type() == QEvent::AccelAvailable ) && qApp->focusWidget() == this ) {
static_cast<QKeyEvent *>( e )->ignore();
return true;
}
if ( obj != this /* when embedded */ && obj != parent() /* when standalone */ )
return FALSE; // not us
if ( e->type() == QEvent::Wheel) {
QApplication::sendEvent(scrollbar, e);
}
#ifdef FAKE_CTRL_AND_ALT
static bool control = FALSE;
static bool alt = FALSE;
// qDebug(" Has a keyboard with no CTRL and ALT keys, but we fake it:");
bool dele=FALSE;
if ( e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease ) {
QKeyEvent* ke = (QKeyEvent*)e;
bool keydown = e->type() == QEvent::KeyPress || ke->isAutoRepeat();
switch (ke->key()) {
case Key_F9: // let this be "Control"
control = keydown;
e = new QKeyEvent(QEvent::KeyPress, Key_Control, 0, ke->state());
dele=TRUE;
break;
case Key_F13: // let this be "Alt"
alt = keydown;
e = new QKeyEvent(QEvent::KeyPress, Key_Alt, 0, ke->state());
dele=TRUE;
break;
default:
if ( control ) {
int a = toupper(ke->ascii())-64;
if ( a >= 0 && a < ' ' ) {
e = new QKeyEvent(e->type(), ke->key(),
a, ke->state()|ControlButton, QChar(a,0));
dele=TRUE;
}
}
if ( alt ) {
e = new QKeyEvent(e->type(), ke->key(),
ke->ascii(), ke->state()|AltButton, ke->text());
dele=TRUE;
}
}
}
#endif
if ( e->type() == QEvent::KeyPress ) {
QKeyEvent* ke = (QKeyEvent*)e;
actSel=0; // Key stroke implies a screen update, so TEWidget won't
// know where the current selection is.
// qDebug("key pressed is 0x%x, ascii is 0x%x, state %d", ke->key(), ke->ascii(), ke->state());
bool special_function = true;
switch(ke->key()) {
// case 0x201b: // fn-5
// case Key_F1:
// switch sessions (?)
// emitText("\\"); // expose (??)
// break;
case 0x2016: // fn-p
case Key_F2:
pasteClipboard();
break;
case 0x2018: // fn-S
case Key_F3:
emit changeSession(1);
break;
case 0x2019: // fn-n
emit newSession();
break;
case Qt::Key_Tab:
if (ke->state() == ControlButton) {
emit changeSession(1);
} else {
special_function = false;
}
break;
#if 0
case Qt::Key_Left:
if (vcolumns == 0) {
emit changeSession(-1);
} else {
special_function = false;
}
break;
case Qt::Key_Right:
if (vcolumns == 0) {
emit changeSession(1);
} else {
special_function = false;
}
break;
#endif
case 0x201b: // fn-5
case Key_F4:
emit toggleFullScreen();
break;
case 0x200f: // fn-1 magnify minus
case Key_F5:
emit changeFontSize(-1);
break;
case 0x2010: // fn-2 magnify plus
case Key_F6:
emit changeFontSize(1);
break;
default:
special_function = false;
}
if (special_function) {
return true;
}
// else if( ke->state() == ControlButton && ke->key() == Key_V) {
// pasteClipboard();
// }
// else if( ke->state() == ControlButton && ke->key() == Key_C) {
// pasteClipboard();
// }
emit keyPressedSignal(ke); // expose
ke->accept();
#ifdef FAKE_CTRL_AND_ALT
if ( dele ) delete e;
#endif
return true; // stop the event
}
if ( e->type() == QEvent::Enter ) {
QObject::disconnect( (QObject*)cb, SIGNAL(dataChanged()),
this, SLOT(onClearSelection()) );
}
if ( e->type() == QEvent::Leave ) {
QObject::connect( (QObject*)cb, SIGNAL(dataChanged()),
this, SLOT(onClearSelection()) );
}
return QFrame::eventFilter( obj, e );
}
/* ------------------------------------------------------------------------- */
/* */
/* Frame */
/* */
/* ------------------------------------------------------------------------- */
void TEWidget::frameChanged()
{
propagateSize();
update();
}
/* ------------------------------------------------------------------------- */
/* */
/* Sound */
/* */
/* ------------------------------------------------------------------------- */
void TEWidget::Bell()
{
//#ifdef QT_QWS_SL5XXX
//# ifndef QT_NO_COP
if(useBeep)
QCopEnvelope( "QPE/TaskBar", "soundAlarm()" );
//# endif
//#else
//# ifndef QT_NO_SOUND
// QSound::play(Resource::findSound("alarm"));
//# endif
//#endif
// QApplication::beep();
}
/* ------------------------------------------------------------------------- */
/* */
/* Auxiluary */
/* */
/* ------------------------------------------------------------------------- */
void TEWidget::clearImage()
// initialize the image
// for internal use only
{
for (int y = 0; y < lines; y++)
for (int x = 0; x < columns; x++)
{
image[loc(x,y)].c = 0xff; //' ';
image[loc(x,y)].f = 0xff; //DEFAULT_FORE_COLOR;
image[loc(x,y)].b = 0xff; //DEFAULT_BACK_COLOR;
image[loc(x,y)].r = 0xff; //DEFAULT_RENDITION;
}
}
// Create Image ///////////////////////////////////////////////////////
void TEWidget::calcGeometry()
{
int showhscrollbar = 1;
int hwidth = 0;
int dcolumns;
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("ScrollBar");
useHorzScroll=cfg.readBoolEntry("HorzScroll",0);
if(vcolumns == 0) showhscrollbar = 0;
if(showhscrollbar == 1) hwidth = QApplication::style().scrollBarExtent().width();
scrollbar->resize(QApplication::style().scrollBarExtent().width(),
contentsRect().height() - hwidth);
switch(scrollLoc) {
case SCRNONE :
columns = ( contentsRect().width() - 2 * rimX ) / font_w;
dcolumns = columns;
if(vcolumns) columns = vcolumns;
blX = (contentsRect().width() - (columns*font_w) ) / 2;
if(showhscrollbar)
blX = -hposition * font_w;
brX = blX;
scrollbar->hide();
break;
case SCRLEFT :
columns = ( contentsRect().width() - 2 * rimX - scrollbar->width()) / font_w;
dcolumns = columns;
if(vcolumns) columns = vcolumns;
brX = (contentsRect().width() - (columns*font_w) - scrollbar->width() ) / 2;
if(showhscrollbar)
brX = -hposition * font_w;
blX = brX + scrollbar->width();
scrollbar->move(contentsRect().topLeft());
scrollbar->show();
break;
case SCRRIGHT:
columns = ( contentsRect().width() - 2 * rimX - scrollbar->width()) / font_w;
dcolumns = columns;
if(vcolumns) columns = vcolumns;
blX = (contentsRect().width() - (columns*font_w) - scrollbar->width() ) / 2;
if(showhscrollbar)
blX = -hposition * font_w;
brX = blX;
scrollbar->move(contentsRect().topRight() - QPoint(scrollbar->width()-1,0));
scrollbar->show();
break;
}
//FIXME: support 'rounding' styles
lines = ( contentsRect().height() - 2 * rimY ) / font_h;
bY = (contentsRect().height() - (lines *font_h)) / 2;
if(showhscrollbar == 1) {
hScrollbar->resize(contentsRect().width() - hwidth, hwidth);
hScrollbar->setRange(0, vcolumns - dcolumns);
QPoint p = contentsRect().bottomLeft();
if(scrollLoc == SCRLEFT)
hScrollbar->move(QPoint(p.x()+hwidth, p.y() - hwidth));
else
hScrollbar->move(QPoint(p.x(), p.y() - hwidth));
hScrollbar->show();
}
else hScrollbar->hide();
if(showhscrollbar == 1) {
lines = lines - (hwidth / font_h) - 1;
if(lines < 1) lines = 1;
}
//FIXME: support 'rounding' styles
}
void TEWidget::makeImage()
//FIXME: rename 'calcGeometry?
{
calcGeometry();
image = (ca*) malloc(lines*columns*sizeof(ca));
clearImage();
}
// calculate the needed size
QSize TEWidget::calcSize(int cols, int lins) const
{
int frw = width() - contentsRect().width();
int frh = height() - contentsRect().height();
int scw = (scrollLoc==SCRNONE?0:scrollbar->width());
return QSize( font_w*cols + 2*rimX + frw + scw, font_h*lins + 2*rimY + frh );
}
QSize TEWidget::sizeHint() const
{
return size();
}
void TEWidget::styleChange(QStyle &)
{
propagateSize();
}
#ifndef QT_NO_DRAGANDDROP
/* --------------------------------------------------------------------- */
/* */
/* Drag & Drop */
/* */
/* --------------------------------------------------------------------- */
void TEWidget::dragEnterEvent(QDragEnterEvent* e)
{
e->accept(QTextDrag::canDecode(e) ||
QUriDrag::canDecode(e));
}
void TEWidget::dropEvent(QDropEvent* event)
{
// The current behaviour when url(s) are dropped is
// * if there is only ONE url and if it's a LOCAL one, ask for paste or cd
// * in all other cases, just paste
// (for non-local ones, or for a list of URLs, 'cd' is nonsense)
QStrList strlist;
int file_count = 0;
dropText = "";
bool bPopup = true;
if(QUriDrag::decode(event, strlist)) {
if (strlist.count()) {
for(const char* p = strlist.first(); p; p = strlist.next()) {
if(file_count++ > 0) {
dropText += " ";
bPopup = false; // more than one file, don't popup
}
/*
KURL url(p);
if (url.isLocalFile()) {
dropText += url.path(); // local URL : remove protocol
}
else {
dropText += url.prettyURL();
bPopup = false; // a non-local file, don't popup
}
*/
}
if (bPopup)
// m_drop->popup(pos() + event->pos());
m_drop->popup(mapToGlobal(event->pos()));
else
{
if (currentSession) {
currentSession->getEmulation()->sendString(dropText.local8Bit());
}
// kdDebug() << "Drop:" << dropText.local8Bit() << "\n";
}
}
}
else if(QTextDrag::decode(event, dropText)) {
// kdDebug() << "Drop:" << dropText.local8Bit() << "\n";
if (currentSession) {
currentSession->getEmulation()->sendString(dropText.local8Bit());
}
// Paste it
}
}
#endif
void TEWidget::drop_menu_activated(int item)
{
#ifndef QT_NO_DRAGANDDROP
switch (item)
{
case 0: // paste
currentSession->getEmulation()->sendString(dropText.local8Bit());
// KWM::activate((Window)this->winId());
break;
case 1: // cd ...
currentSession->getEmulation()->sendString("cd ");
struct stat statbuf;
if ( ::stat( QFile::encodeName( dropText ), &statbuf ) == 0 )
{
if ( !S_ISDIR(statbuf.st_mode) )
{
/*
KURL url;
url.setPath( dropText );
dropText = url.directory( true, false ); // remove filename
*/
}
}
dropText.replace(QRegExp(" "), "\\ "); // escape spaces
currentSession->getEmulation()->sendString(dropText.local8Bit());
currentSession->getEmulation()->sendString("\n");
// KWM::activate((Window)this->winId());
break;
}
#endif
}
void TEWidget::setWrapAt(int columns)
{
vcolumns = columns;
propagateSize();
update();
}
diff --git a/core/apps/embeddedkonsole/commandeditdialog.cpp b/core/apps/embeddedkonsole/commandeditdialog.cpp
index 03cba87..b23db18 100644
--- a/core/apps/embeddedkonsole/commandeditdialog.cpp
+++ b/core/apps/embeddedkonsole/commandeditdialog.cpp
@@ -1,199 +1,199 @@
//comandeditdialog.cpp
#include "commandeditdialog.h"
#include "playlistselection.h"
#include <qstring.h>
#include <qpe/config.h>
#include <qtoolbar.h>
#include <qwidget.h>
#include <qmenubar.h>
#include <qpe/resource.h>
#include <qlist.h>
#include <qtoolbutton.h>
#include <qvbox.h>
#include <qlistview.h>
#include <qlineedit.h>
#include <qheader.h>
#include <qlabel.h>
#include <qmessagebox.h>
#include "smallcommandeditdialogbase.h"
CommandEditDialog::CommandEditDialog(QWidget *parent, const char* name, WFlags fl )
: CommandEditDialogBase(parent, name, TRUE, fl)
{
m_SuggestedCommandList->addColumn( tr("Command Selection") );
m_SuggestedCommandList->header()->hide();
m_SuggestedCommandList->setSorting(-1,FALSE);
m_SuggestedCommandList->clearSelection();
m_SuggestedCommandList->setSorting(0,TRUE);
QListViewItem *item;
item = new QListViewItem( m_SuggestedCommandList,"export ");
item = new QListViewItem( m_SuggestedCommandList,"ifconfig ");
item = new QListViewItem( m_SuggestedCommandList,"ipkg ");
item = new QListViewItem( m_SuggestedCommandList,"gzip ");
item = new QListViewItem( m_SuggestedCommandList,"gunzip ");
item = new QListViewItem( m_SuggestedCommandList,"chgrp ");
item = new QListViewItem( m_SuggestedCommandList,"chown ");
item = new QListViewItem( m_SuggestedCommandList,"date ");
item = new QListViewItem( m_SuggestedCommandList,"dd ");
item = new QListViewItem( m_SuggestedCommandList,"dmesg ");
item = new QListViewItem( m_SuggestedCommandList,"fuser ");
item = new QListViewItem( m_SuggestedCommandList,"hostname ");
item = new QListViewItem( m_SuggestedCommandList,"kill ");
item = new QListViewItem( m_SuggestedCommandList,"killall ");
item = new QListViewItem( m_SuggestedCommandList,"ln ");
item = new QListViewItem( m_SuggestedCommandList,"ln -s ");
item = new QListViewItem( m_SuggestedCommandList,"lsmod");
item = new QListViewItem( m_SuggestedCommandList,"depmod -a");
item = new QListViewItem( m_SuggestedCommandList,"modprobe ");
item = new QListViewItem( m_SuggestedCommandList,"mount ");
item = new QListViewItem( m_SuggestedCommandList,"more ");
item = new QListViewItem( m_SuggestedCommandList,"sort ");
item = new QListViewItem( m_SuggestedCommandList,"touch ");
item = new QListViewItem( m_SuggestedCommandList,"umount ");
item = new QListViewItem( m_SuggestedCommandList,"mknod ");
item = new QListViewItem( m_SuggestedCommandList,"netstat ");
item = new QListViewItem( m_SuggestedCommandList,"route ");
item = new QListViewItem( m_SuggestedCommandList,"cardctl eject ");
m_SuggestedCommandList->setSelected(m_SuggestedCommandList->firstChild(),TRUE);
m_SuggestedCommandList->sort();
connect( m_SuggestedCommandList, SIGNAL( clicked( QListViewItem * ) ), m_PlayListSelection, SLOT( addToSelection( QListViewItem *) ) );
ToolButton1->setTextLabel("new");
ToolButton1->setPixmap(Resource::loadPixmap("new"));
ToolButton1->setAutoRaise(TRUE);
ToolButton1->setFocusPolicy(QWidget::NoFocus);
connect(ToolButton1,SIGNAL(clicked()),this,SLOT(showAddDialog()));
ToolButton2->setTextLabel("edit");
ToolButton2->setPixmap(Resource::loadPixmap("edit"));
ToolButton2->setAutoRaise(TRUE);
ToolButton2->setFocusPolicy(QWidget::NoFocus);
connect(ToolButton2,SIGNAL(clicked()),this,SLOT(showEditDialog()));
ToolButton3->setTextLabel("delete");
ToolButton3->setPixmap(Resource::loadPixmap("editdelete"));
ToolButton3->setAutoRaise(TRUE);
ToolButton3->setFocusPolicy(QWidget::NoFocus);
connect(ToolButton3,SIGNAL(clicked()),m_PlayListSelection,SLOT(removeSelected()));
ToolButton4->setTextLabel("up");
ToolButton4->setPixmap(Resource::loadPixmap("up"));
ToolButton4->setAutoRaise(TRUE);
ToolButton4->setFocusPolicy(QWidget::NoFocus);
connect(ToolButton4,SIGNAL(clicked()),m_PlayListSelection,SLOT(moveSelectedUp()));
ToolButton5->setTextLabel("down");
ToolButton5->setPixmap(Resource::loadPixmap("down"));
ToolButton5->setAutoRaise(TRUE);
ToolButton5->setFocusPolicy(QWidget::NoFocus);
connect(ToolButton5,SIGNAL(clicked()),m_PlayListSelection,SLOT(moveSelectedDown()));
QListViewItem *current = m_SuggestedCommandList->selectedItem();
if ( current )
item->moveItem( current );
m_SuggestedCommandList->setSelected( item, TRUE );
m_SuggestedCommandList->ensureItemVisible( m_SuggestedCommandList->selectedItem() );
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Commands");
if (cfg.readEntry("Commands Set","FALSE") == "TRUE") {
for (int i = 0; i < 100; i++) {
QString tmp;
tmp = cfg.readEntry( QString::number(i),"");
if (!tmp.isEmpty())
m_PlayListSelection->addStringToSelection(tmp);
}
} else {
m_PlayListSelection->addStringToSelection("ls ");
m_PlayListSelection->addStringToSelection("cardctl eject");
m_PlayListSelection->addStringToSelection("cat ");
m_PlayListSelection->addStringToSelection("cd ");
m_PlayListSelection->addStringToSelection("chmod ");
m_PlayListSelection->addStringToSelection("cp ");
m_PlayListSelection->addStringToSelection("dc ");
m_PlayListSelection->addStringToSelection("df ");
m_PlayListSelection->addStringToSelection("dmesg");
m_PlayListSelection->addStringToSelection("echo ");
m_PlayListSelection->addStringToSelection("env");
m_PlayListSelection->addStringToSelection("find ");
m_PlayListSelection->addStringToSelection("free");
m_PlayListSelection->addStringToSelection("grep ");
m_PlayListSelection->addStringToSelection("ifconfig ");
m_PlayListSelection->addStringToSelection("ipkg ");
m_PlayListSelection->addStringToSelection("mkdir ");
m_PlayListSelection->addStringToSelection("mv ");
m_PlayListSelection->addStringToSelection("nc localhost 7776");
m_PlayListSelection->addStringToSelection("nc localhost 7777");
m_PlayListSelection->addStringToSelection("nslookup ");
m_PlayListSelection->addStringToSelection("ping ");
m_PlayListSelection->addStringToSelection("ps aux");
m_PlayListSelection->addStringToSelection("pwd ");
m_PlayListSelection->addStringToSelection("rm ");
m_PlayListSelection->addStringToSelection("rmdir ");
m_PlayListSelection->addStringToSelection("route ");
m_PlayListSelection->addStringToSelection("set ");
m_PlayListSelection->addStringToSelection("traceroute");
}
}
CommandEditDialog::~CommandEditDialog()
{
}
void CommandEditDialog::accept()
{
int i = 0;
Config *cfg = new Config("Qkonsole");
cfg->setGroup("Commands");
cfg->clearGroup();
QListViewItemIterator it( m_PlayListSelection );
for ( ; it.current(); ++it ) {
// qDebug(it.current()->text(0));
cfg->writeEntry(QString::number(i),it.current()->text(0));
i++;
}
cfg->writeEntry("Commands Set","TRUE");
// qDebug("CommandEditDialog::accept() - written");
delete cfg;
emit commandsEdited();
close();
}
void CommandEditDialog::showEditDialog()
{
editCommandBase *d = new editCommandBase(this,"smalleditdialog", TRUE);
d->setCaption("Edit command");
d->TextLabel->setText("Edit command:");
d->commandEdit->setText(m_PlayListSelection->currentItem()->text(0));
int i = d->exec();
if ((i==1) && (!(d->commandEdit->text()).isEmpty()))
m_PlayListSelection->currentItem()->setText(0,(d->commandEdit->text()));
}
void CommandEditDialog::showAddDialog()
{
editCommandBase *d = new editCommandBase(this,"smalleditdialog", TRUE);
int i = d->exec();
if ((i==1) && (!(d->commandEdit->text()).isEmpty()))
m_PlayListSelection->addStringToSelection(d->commandEdit->text());
}
diff --git a/core/apps/embeddedkonsole/konsole.cpp b/core/apps/embeddedkonsole/konsole.cpp
index 46c0203..3289a04 100644
--- a/core/apps/embeddedkonsole/konsole.cpp
+++ b/core/apps/embeddedkonsole/konsole.cpp
@@ -1,1918 +1,1919 @@
/* ---------------------------------------------------------------------- */
/* */
/* [main.C] Konsole */
/* */
/* ---------------------------------------------------------------------- */
/* */
/* Copyright (c) 1997,1998 by Lars Doelle <lars.doelle@on-line.de> */
/* */
/* This file is part of Konsole, an X terminal. */
/* */
/* The material contained in here more or less directly orginates from */
/* kvt, which is copyright (c) 1996 by Matthias Ettrich <ettrich@kde.org> */
/* */
/* ---------------------------------------------------------------------- */
/* */
/* Ported Konsole to Qt/Embedded */
/* */
/* Copyright (C) 2000 by John Ryland <jryland@trolltech.com> */
/* */
/* -------------------------------------------------------------------------- */
// enhancements added by L.J. Potter <ljp@llornkcor.com>
+// enhancements added by Phillip Kuhn
//#define QT_QWS_OPIE
#include <stdlib.h>
#ifdef QT_QWS_OPIE
#include <opie2/ocolorpopupmenu.h>
#endif
#include <qpe/resource.h>
#include <qdir.h>
#include <qevent.h>
#include <qdragobject.h>
#include <qobjectlist.h>
#include <qtoolbutton.h>
#include <qtoolbar.h>
#include <qpushbutton.h>
#include <qfontdialog.h>
#include <qglobal.h>
#include <qpainter.h>
#include <qmenubar.h>
#include <qmessagebox.h>
#include <qaction.h>
#include <qapplication.h>
#include <qfontmetrics.h>
#include <qcombobox.h>
#include <qevent.h>
#include <qtabwidget.h>
#include <qtabbar.h>
#include <qpe/config.h>
#include <qstringlist.h>
#include <qpalette.h>
#include <qfontdatabase.h>
#include <qfile.h>
#include <qspinbox.h>
#include <qlayout.h>
#include <qvbox.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "konsole.h"
#include "keytrans.h"
#include "commandeditdialog.h"
class EKNumTabBar : public QTabBar
{
public:
EKNumTabBar(QWidget *parent = 0, const char *name = 0) :
QTabBar(parent, name)
{}
// QList<QTab> *getTabList() { return(tabList()); }
void numberTabs()
{
// Yes, it really is this messy. QTabWidget needs functions
// that provide acces to tabs in a sequential way.
int m=INT_MIN;
for (int i=0; i<count(); i++)
{
QTab* left=0;
QListIterator<QTab> it(*tabList());
int x=INT_MAX;
for( QTab* t; (t=it.current()); ++it )
{
int tx = t->rect().x();
if ( tx<x && tx>m )
{
x = tx;
left = t;
}
}
if ( left )
{
left->setText(QString::number(i+1));
m = left->rect().x();
}
}
}
virtual QSize sizeHint() const
{
if (isHidden())
{
return(QSize(0,0));
}
else
{
QSize size = QTabBar::sizeHint();
int shrink = 5;
if (qApp->desktop()->width() > 600 || qApp->desktop()->height() > 600)
{
shrink = 10;
}
size.setHeight(size.height() - shrink);
return(size);
}
}
};
class EKNumTabWidget : public QTabWidget
{
public:
EKNumTabWidget(QWidget* parent) : QTabWidget(parent)
{
setTabBar(new EKNumTabBar(parent,"EKTabBar"));
setSizePolicy( QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding ) );
}
EKNumTabBar *getTabBar() const
{
return ((EKNumTabBar*)tabBar());
}
void addTab(QWidget* w)
{
QTab* t = new QTab(QString::number(tabBar()->count()+1));
QTabWidget::addTab(w,t);
}
void removeTab(QWidget* w)
{
removePage(w);
((EKNumTabBar*)tabBar())->numberTabs();
}
};
// This could be configurable or dynamicly generated from the bash history
// file of the user
static const char *commonCmds[] =
{
"ls ", // I left this here, cause it looks better than the first alpha
"cardctl eject",
"cat ",
"cd ",
"chmod ",
"clear",
"cp ",
"dc ",
"df ",
"dmesg",
"echo ",
"env",
"find ",
"free",
"grep ",
"ifconfig ",
"ipkg ",
"mkdir ",
"mv ",
"nc localhost 7776",
"nc localhost 7777",
"netstat ",
"nslookup ",
"ping ",
"ps aux",
"pwd ",
"qcop QPE/System 'linkChanged(QString)' ''",
"qcop QPE/System 'restart()'",
"qcop QPE/System 'quit()'",
"rm ",
"rmdir ",
"route ",
"set ",
"traceroute",
/*
"gzip",
"gunzip",
"chgrp",
"chown",
"date",
"dd",
"df",
"dmesg",
"fuser",
"hostname",
"kill",
"killall",
"ln",
"ping",
"mount",
"more",
"sort",
"touch",
"umount",
"mknod",
"netstat",
*/
"exit",
NULL
};
Konsole::Konsole(QWidget* parent, const char* name, WFlags fl) :
QMainWindow(parent, name, fl)
{
QStrList args;
init("/bin/bash",args);
}
Konsole::Konsole(const char* name, const char* _pgm, QStrList & _args, int)
: QMainWindow(0, name)
{
init(_pgm,_args);
}
struct HistoryItem
{
HistoryItem(int c, const QString &l)
{
count = c;
line = l;
}
int count;
QString line;
};
class HistoryList : public QList<HistoryItem>
{
virtual int compareItems( QCollection::Item item1, QCollection::Item item2)
{
int c1 = ((HistoryItem*)item1)->count;
int c2 = ((HistoryItem*)item2)->count;
if (c1 > c2)
return(1);
if (c1 < c2)
return(-1);
return(0);
}
};
void Konsole::initCommandList()
{
// qDebug("Konsole::initCommandList");
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Commands");
// commonCombo->setInsertionPolicy(QComboBox::AtCurrent);
commonCombo->clear();
if (cfg.readEntry("ShellHistory","TRUE") == "TRUE")
{
QString histfilename = QString(getenv("HOME")) + "/.bash_history";
histfilename = cfg.readEntry("ShellHistoryPath",histfilename);
QFile histfile(histfilename);
// note: compiler barfed on:
// QFile histfile(QString(getenv("HOME")) + "/.bash_history");
if (histfile.open( IO_ReadOnly ))
{
QString line;
uint i;
HistoryList items;
int lineno = 0;
while(!histfile.atEnd())
{
if (histfile.readLine(line, 200) < 0)
{
break;
}
line = line.left(line.length()-1);
lineno++;
for(i=0; i<items.count(); i++)
{
if (line == items.at(i)->line)
{
// weight recent commands & repeated commands more
// by adding up the index of each command
items.at(i)->count += lineno;
break;
}
}
if (i >= items.count())
{
items.append(new HistoryItem(lineno, line));
}
}
items.sort();
int n = items.count();
if (n > 40)
{
n = 40;
}
for(int i=0; i<n; i++)
{
// should insert start of command, but keep whole thing
if (items.at(items.count()-i-1)->line.length() < 30)
{
commonCombo->insertItem(items.at(items.count()-i-1)->line);
}
}
histfile.close();
}
}
if (cfg.readEntry("Commands Set","FALSE") == "FALSE")
{
for (int i = 0; commonCmds[i] != NULL; i++)
{
commonCombo->insertItem(commonCmds[i]);
}
}
else
{
for (int i = 0; i < 100; i++)
{
if (!(cfg.readEntry( QString::number(i),"")).isEmpty())
commonCombo->insertItem(cfg.readEntry( QString::number(i),""));
}
}
}
static void sig_handler(int x)
{
printf("got signal %d\n",x);
}
void Konsole::init(const char* _pgm, QStrList & _args)
{
#if 0
for(int i=1; i<=31; i++)
{
if (i != SIGPIPE && i != SIGPROF && i != SIGSEGV
&& i != SIGINT && i != SIGILL && i != SIGTERM
&& i != SIGBUS)
signal(i,sig_handler);
}
#endif
signal(SIGSTOP, sig_handler);
signal(SIGCONT, sig_handler);
signal(SIGTSTP, sig_handler);
b_scroll = TRUE; // histon;
n_keytab = 0;
n_render = 0;
startUp=0;
fromMenu = FALSE;
fullscreen = false;
setCaption( "Qkonsole" );
setIcon( Resource::loadPixmap( "qkonsole/qkonsole" ) );
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Font");
QString tmp;
// initialize the list of allowed fonts ///////////////////////////////////
QString cfgFontName = cfg.readEntry("FontName","Lcfont");
int cfgFontSize = cfg.readNumEntry("FontSize",18);
cfont = -1;
// this code causes repeated access to all the font files
// which does slow down startup
QFontDatabase fontDB;
QStringList familyNames;
familyNames = fontDB.families( FALSE );
QString s;
int fontIndex = 0;
int familyNum = 0;
fontList = new QPopupMenu( this );
for(uint j = 0; j < (uint)familyNames.count(); j++)
{
s = familyNames[j];
if ( s.contains('-') )
{
int i = s.find('-');
s = s.right( s.length() - i - 1 ) + " [" + s.left( i ) + "]";
}
s[0] = s[0].upper();
QValueList<int> sizes = fontDB.pointSizes( familyNames[j] );
printf("family[%d] = %s with %d sizes\n", j, familyNames[j].latin1(),
sizes.count());
if (sizes.count() > 0)
{
QPopupMenu *sizeMenu;
QFont f;
int last_width = -1;
sizeMenu = NULL;
for(uint i = 0; i < (uint)sizes.count() + 4; i++)
{
// printf("family %s size %d ", familyNames[j].latin1(), sizes[i]);
// need to divide by 10 on the Z, but not otherwise
int size;
if (i >= (uint)sizes.count())
{
// try for expandable fonts
size = sizes[sizes.count()-1] + 2 * (i - sizes.count() + 1);
}
else
{
printf("sizes[%d] = %d\n", i, sizes[i]);
size = sizes[i];
}
#ifndef __i386__
// a hack, sizes on Z seem to be points*10
size /= 10;
#endif
f = QFont(familyNames[j], size);
f.setFixedPitch(true);
QFontMetrics fm(f);
// don't trust f.fixedPitch() or f.exactMatch(), they lie!!
if (fm.width("l") == fm.width("m")
&& (i < (uint)sizes.count()
|| fm.width("m") > last_width))
{
if (i < (uint)sizes.count())
{
last_width = fm.width("m");
}
if (sizeMenu == NULL)
{
sizeMenu = new QPopupMenu();
}
int id = sizeMenu->insertItem(QString("%1").arg(size), fontIndex);
sizeMenu->setItemParameter(id, fontIndex);
sizeMenu->connectItem(id, this, SLOT(setFont(int)));
QString name = s + " " + QString::number(size);
fonts.append(new VTFont(name, f, familyNames[j], familyNum, size));
if (familyNames[j] == cfgFontName && size == cfgFontSize)
{
cfont = fontIndex;
}
printf("FOUND: %s family %s size %d\n", name.latin1(), familyNames[j].latin1(), size);
fontIndex++;
}
}
if (sizeMenu)
{
fontList->insertItem(s, sizeMenu, familyNum + 1000);
familyNum++;
}
}
}
if (cfont < 0 || cfont >= (int)fonts.count())
{
cfont = 0;
}
// create terminal emulation framework ////////////////////////////////////
nsessions = 0;
tab = new EKNumTabWidget(this);
// tab->setMargin(tab->margin()-5);
connect(tab, SIGNAL(currentChanged(QWidget*)), this, SLOT(switchSession(QWidget*)));
// create terminal toolbar ////////////////////////////////////////////////
setToolBarsMovable( FALSE );
menuToolBar = new QToolBar( this );
menuToolBar->setHorizontalStretchable( TRUE );
QMenuBar *menuBar = new QMenuBar( menuToolBar );
bool c7xx = false;
if (qApp->desktop()->width() > 600 || qApp->desktop()->height() > 600)
{
c7xx = true;
}
QFont menuFont;
menuFont.setPointSize(c7xx? 18 : 10);
qApp->setFont(menuFont, true);
setFont(cfont);
configMenu = new QPopupMenu( this);
colorMenu = new QPopupMenu( this);
scrollMenu = new QPopupMenu( this);
editCommandListMenu = new QPopupMenu( this);
configMenu->insertItem(tr("Command List"), editCommandListMenu);
bool listHidden;
cfg.setGroup("Menubar");
if( cfg.readEntry("Hidden","FALSE") == "TRUE")
{
ec_cmdlist = editCommandListMenu->insertItem( tr( "Show command list" ));
listHidden=TRUE;
}
else
{
ec_cmdlist = editCommandListMenu->insertItem( tr( "Hide command list" ));
listHidden=FALSE;
}
cfg.setGroup("Tabs");
tabMenu = new QPopupMenu(this);
tm_bottom = tabMenu->insertItem(tr("Bottom" ));
tm_top = tabMenu->insertItem(tr("Top"));
tm_hidden = tabMenu->insertItem(tr("Hidden"));
configMenu->insertItem(tr("Tabs"), tabMenu);
tmp=cfg.readEntry("Position","Top");
if(tmp=="Top")
{
tab->setTabPosition(QTabWidget::Top);
tab->getTabBar()->show();
tabPos = tm_top;
}
else if (tmp=="Bottom")
{
tab->setTabPosition(QTabWidget::Bottom);
tab->getTabBar()->show();
tabPos = tm_bottom;
}
else
{
tab->getTabBar()->hide();
tab->setMargin(tab->margin());
tabPos = tm_hidden;
}
cm_bw = colorMenu->insertItem(tr( "Black on White"));
cm_wb = colorMenu->insertItem(tr( "White on Black"));
cm_gb = colorMenu->insertItem(tr( "Green on Black"));
// cm_bt = colorMenu->insertItem(tr( "Black on Transparent"));
cm_br = colorMenu->insertItem(tr( "Black on Pink"));
cm_rb = colorMenu->insertItem(tr( "Pink on Black"));
cm_gy = colorMenu->insertItem(tr( "Green on Yellow"));
cm_bm = colorMenu->insertItem(tr( "Blue on Magenta"));
cm_mb = colorMenu->insertItem(tr( "Magenta on Blue"));
cm_cw = colorMenu->insertItem(tr( "Cyan on White"));
cm_wc = colorMenu->insertItem(tr( "White on Cyan"));
cm_bb = colorMenu->insertItem(tr( "Blue on Black"));
cm_ab = colorMenu->insertItem(tr( "Amber on Black"));
cm_default = colorMenu->insertItem(tr("default"));
#ifdef QT_QWS_OPIE
colorMenu->insertItem(tr( "Custom"));
#endif
configMenu->insertItem(tr( "Colors") ,colorMenu);
sessionList = new QPopupMenu(this);
sessionList-> insertItem ( Resource::loadPixmap ( "qkonsole/qkonsole" ), tr( "new session" ), this,
SLOT(newSession()) );
// connect( fontList, SIGNAL( activated(int) ), this, SLOT( fontChanged(int) ));
connect( configMenu, SIGNAL( activated(int) ), this, SLOT( configMenuSelected(int) ));
connect( colorMenu, SIGNAL( activated(int) ), this, SLOT( colorMenuIsSelected(int) ));
connect( tabMenu, SIGNAL( activated(int) ), this, SLOT( tabMenuSelected(int) ));
connect( scrollMenu, SIGNAL(activated(int)),this,SLOT(scrollMenuSelected(int)));
connect( editCommandListMenu,SIGNAL(activated(int)),this,SLOT(editCommandListMenuSelected(int)));
connect( sessionList, SIGNAL(activated(int)), this, SLOT( sessionListSelected(int) ) );
menuBar->insertItem( tr("View"), configMenu );
menuBar->insertItem( tr("Fonts"), fontList );
menuBar->insertItem( tr("Sessions"), sessionList );
toolBar = new QToolBar( this );
QAction *a;
// Button Commands
a = new QAction( tr("New"), Resource::loadPixmap( "konsole/Terminal" ), QString::null, 0, this, 0 );
connect( a, SIGNAL( activated() ), this, SLOT( newSession() ) );
a->addTo( toolBar );
a = new QAction( tr("Full Screen"), Resource::loadPixmap( "fullscreen" ), QString::null, 0, this, 0 );
connect( a, SIGNAL( activated() ), this, SLOT( toggleFullScreen() ) );
a->addTo( toolBar );
a = new QAction( tr("Zoom"), Resource::loadPixmap( "zoom" ), QString::null, 0, this, 0 );
connect( a, SIGNAL( activated() ), this, SLOT( cycleZoom() ) );
a->addTo( toolBar );
/*
a = new QAction( tr("Enter"), Resource::loadPixmap( "konsole/enter" ), QString::null, 0, this, 0 );
connect( a, SIGNAL( activated() ), this, SLOT( hitEnter() ) ); a->addTo( toolBar );
a = new QAction( tr("Space"), Resource::loadPixmap( "konsole/space" ), QString::null, 0, this, 0 );
connect( a, SIGNAL( activated() ), this, SLOT( hitSpace() ) ); a->addTo( toolBar );
a = new QAction( tr("Tab"), Resource::loadPixmap( "konsole/tab" ), QString::null, 0, this, 0 );
connect( a, SIGNAL( activated() ), this, SLOT( hitTab() ) ); a->addTo( toolBar );
*/
/*
a = new QAction( tr("Up"), Resource::loadPixmap( "konsole/up" ), QString::null, 0, this, 0 );
connect( a, SIGNAL( activated() ), this, SLOT( hitUp() ) ); a->addTo( toolBar );
a = new QAction( tr("Down"), Resource::loadPixmap( "konsole/down" ), QString::null, 0, this, 0 );
connect( a, SIGNAL( activated() ), this, SLOT( hitDown() ) ); a->addTo( toolBar );
*/
a = new QAction( tr("Paste"), Resource::loadPixmap( "paste" ), QString::null, 0, this, 0 );
connect( a, SIGNAL( activated() ), this, SLOT( hitPaste() ) );
a->addTo( toolBar );
secondToolBar = new QToolBar( this );
secondToolBar->setHorizontalStretchable( TRUE );
commonCombo = new QComboBox( secondToolBar );
// commonCombo->setMaximumWidth(236);
ec_quick = editCommandListMenu->insertItem( tr( "Quick Edit" ) );
if( listHidden)
{
secondToolBar->hide();
editCommandListMenu->setItemEnabled(ec_quick ,FALSE);
}
ec_edit = editCommandListMenu->insertItem(tr( "Edit" ) );
cfg.setGroup("Commands");
commonCombo->setInsertionPolicy(QComboBox::AtCurrent);
initCommandList();
// for (int i = 0; commonCmds[i] != NULL; i++) {
// commonCombo->insertItem( commonCmds[i], i );
// tmp = cfg.readEntry( QString::number(i),"");
// if(tmp != "")
// commonCombo->changeItem( tmp,i );
// }
connect( commonCombo, SIGNAL( activated(int) ), this, SLOT( enterCommand(int) ));
sm_none = scrollMenu->insertItem(tr( "None" ));
sm_left = scrollMenu->insertItem(tr( "Left" ));
sm_right = scrollMenu->insertItem(tr( "Right" ));
// scrollMenu->insertSeparator(4);
// scrollMenu->insertItem(tr( "Horizontal" ));
configMenu->insertItem(tr( "ScrollBar" ),scrollMenu);
configMenu->insertItem(tr( "History" ), this, SLOT(historyDialog()));
cm_wrap = configMenu->insertItem(tr( "Wrap" ));
cfg.setGroup("ScrollBar");
configMenu->setItemChecked(cm_wrap, cfg.readBoolEntry("HorzScroll",0));
cm_beep = configMenu->insertItem(tr( "Use Beep" ));
cfg.setGroup("Menubar");
configMenu->setItemChecked(cm_beep, cfg.readBoolEntry("useBeep",0));
fullscreen_msg = new QLabel(this);
fullscreen_msg-> setAlignment ( AlignCenter | SingleLine );
fullscreen_msg-> hide();
fullscreen_msg-> setSizePolicy ( QSizePolicy ( QSizePolicy::Expanding, QSizePolicy::Expanding ));
fullscreen_msg-> setAutoResize(true);
fullscreen_msg-> setFrameStyle(QFrame::PopupPanel | QFrame::Raised);
fullscreen_msg-> setText(tr("To exit fullscreen, tap here."));
fullscreen_timer = new QTimer(this);
connect(fullscreen_timer, SIGNAL(timeout()),
this, SLOT(fullscreenTimeout()));
show_fullscreen_msg = true;
//scrollMenuSelected(-29);
// cfg.setGroup("ScrollBar");
// if(cfg.readBoolEntry("HorzScroll",0)) {
// if(cfg.readNumEntry("Position",2) == 0)
// te->setScrollbarLocation(1);
// else
// te->setScrollbarLocation(0);
// te->setScrollbarLocation( cfg.readNumEntry("Position",2));
// te->setWrapAt(120);
// }
// create applications /////////////////////////////////////////////////////
setCentralWidget(tab);
// load keymaps ////////////////////////////////////////////////////////////
KeyTrans::loadAll();
for (int i = 0; i < KeyTrans::count(); i++)
{
KeyTrans* s = KeyTrans::find(i);
assert( s );
}
se_pgm = _pgm;
se_args = _args;
cfg.setGroup("CommandLine");
if (cfg.hasKey("shell_args"))
{
QStringList se_args_list = cfg.readListEntry("shell_args",'|');
for(uint i = 0; i < se_args_list.count(); i++)
{
se_args.prepend(se_args_list[se_args_list.count() - i - 1].latin1());
}
}
else
{
se_args.prepend("--login");
}
se_pgm = cfg.readEntry("shell_bin", QString(se_pgm));
// this is the "documentation" for those who know to look
if (! cfg.hasKey("shell_args"))
{
cfg.writeEntry("shell_args",QStringList::fromStrList(se_args),'|');
}
if (! cfg.hasKey("shell_bin"))
{
cfg.writeEntry("shell_bin",QString(se_pgm));
}
parseCommandLine();
// read and apply default values ///////////////////////////////////////////
resize(321, 321); // Dummy.
QSize currentSize = size();
if (currentSize != size())
defaultSize = size();
/* allows us to catch cancel/escape */
reparent ( 0, WStyle_Customize | WStyle_NoBorder,
QPoint ( 0, 0 ));
}
void Konsole::show()
{
if ( !nsessions )
{
newSession();
}
QMainWindow::show();
}
void Konsole::initSession(const char*, QStrList &)
{
QMainWindow::show();
}
Konsole::~Konsole()
{
while (nsessions > 0)
{
doneSession(getTe(), 0);
}
}
void
Konsole::historyDialog()
{
QDialog *d = new QDialog ( this, "histdlg", true );
// d-> setCaption ( tr( "History" ));
QBoxLayout *lay = new QVBoxLayout ( d, 4, 4 );
QLabel *l = new QLabel ( tr( "History Lines:" ), d );
lay-> addWidget ( l );
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("History");
int hist = cfg.readNumEntry("history_lines",300);
int avg_line = cfg.readNumEntry("avg_line_length",60);
QSpinBox *spin = new QSpinBox ( 1, 100000, 20, d );
spin-> setValue ( hist );
spin-> setWrapping ( true );
spin-> setButtonSymbols ( QSpinBox::PlusMinus );
lay-> addWidget ( spin );
if ( d-> exec ( ) == QDialog::Accepted )
{
cfg.writeEntry("history_lines", spin->value());
cfg.writeEntry("avg_line_length", avg_line);
if (getTe() != NULL)
{
getTe()->currentSession->setHistory(true);
}
}
delete d;
}
void Konsole::cycleZoom()
{
TEWidget* te = getTe();
QFont font = te->getVTFont();
int size = font.pointSize();
changeFontSize(1);
font = te->getVTFont();
if (font.pointSize() <= size)
{
do
{
font = te->getVTFont();
size = font.pointSize();
changeFontSize(-1);
font = te->getVTFont();
}
while (font.pointSize() < size);
}
}
void Konsole::changeFontSize(int delta)
{
// printf("delta font size %d\n", delta);
TEWidget* te = getTe();
QFont font = te->getVTFont();
int size = font.pointSize();
int closest = delta > 0? 10000 : -10000;
int closest_font = -1;
for(uint i = 0; i < fonts.count(); i++)
{
if (fonts.at(i)->getFont() == font)
{
if (delta > 0)
{
if (i+1 < fonts.count()
&& fonts.at(i+1)->getFamilyNum() == fonts.at(i)->getFamilyNum())
{
setFont(i+1);
printf("font %d\n", i+1);
return;
}
}
else if (delta < 0)
{
if (i > 0
&& fonts.at(i-1)->getFamilyNum() == fonts.at(i)->getFamilyNum())
{
setFont(i-1);
printf("font %d\n", i-1);
return;
}
}
}
int fsize = fonts.at(i)->getSize();
printf("%d size=%d fsize=%d closest=%d\n", i, size, fsize, closest);
if ((delta > 0 && fsize > size && fsize < closest)
|| (delta < 0 && fsize < size && fsize > closest))
{
closest = fsize;
closest_font = i;
}
}
if (closest_font >= 0)
{
printf("font closest %d (%d)\n", closest_font, closest);
setFont(closest_font);
}
}
int Konsole::findFont(QString name, int size, bool exactMatch)
{
for(uint i = 0; i < fonts.count(); i++)
{
if (fonts.at(i)->getName() == name
&& fonts.at(i)->getSize() == size)
{
return(i);
}
}
if (exactMatch)
{
return(-1);
}
for(uint i = 0; i < fonts.count(); i++)
{
if (fonts.at(i)->getSize() == size)
{
return(i);
}
}
return(-1);
}
void Konsole::setFont(int f)
{
VTFont* font = fonts.at(f);
if (font)
{
TEWidget* te = getTe();
if (te != 0)
{
te->setVTFont(font->getFont());
}
cfont = f;
int familyNum = font->getFamilyNum();
int size = font->getSize();
printf("familyNum = %d size = %d count=%d\n", familyNum, size,
fontList->count());
for(int i = 0; i < (int)fontList->count(); i++)
{
fontList->setItemChecked(i + 1000, i == familyNum);
}
for(int i = 0; i < (int)fonts.count(); i++)
{
fontList->setItemChecked(i, fonts.at(i)->getFamilyNum() == familyNum
&& fonts.at(i)->getSize() == size);
}
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Font");
QString ss = "Session"+ QString::number(tab->currentPageIndex()+1);
if (tab->currentPageIndex() == 0)
{
cfg.writeEntry("FontName", fonts.at(cfont)->getFamily());
cfg.writeEntry("FontSize", fonts.at(cfont)->getSize());
}
cfg.writeEntry("FontName"+ss, fonts.at(cfont)->getFamily());
cfg.writeEntry("FontSize"+ss, fonts.at(cfont)->getSize());
}
}
#if 0
void Konsole::fontChanged(int f)
{
VTFont* font = fonts.at(f);
if (font != 0)
{
for(uint i = 0; i < fonts.count(); i++)
{
fontList->setItemChecked(i, (i == (uint) f) ? TRUE : FALSE);
}
cfont = f;
TEWidget* te = getTe();
if (te != 0)
{
te->setVTFont(font->getFont());
}
}
}
#endif
void Konsole::enterCommand(int c)
{
TEWidget* te = getTe();
if (te != 0)
{
if(!commonCombo->editable())
{
QString text = commonCombo->text(c); //commonCmds[c];
te->emitText(text);
}
else
{
changeCommand( commonCombo->text(c), c);
}
}
}
void Konsole::hitEnter()
{
TEWidget* te = getTe();
if (te != 0)
{
te->emitText(QString("\r"));
}
}
void Konsole::hitSpace()
{
TEWidget* te = getTe();
if (te != 0)
{
te->emitText(QString(" "));
}
}
void Konsole::hitTab()
{
TEWidget* te = getTe();
if (te != 0)
{
te->emitText(QString("\t"));
}
}
void Konsole::hitPaste()
{
TEWidget* te = getTe();
if (te != 0)
{
te->pasteClipboard();
}
}
void Konsole::hitUp()
{
TEWidget* te = getTe();
if (te != 0)
{
QKeyEvent ke( QKeyEvent::KeyPress, Qt::Key_Up, 0, 0);
QApplication::sendEvent( te, &ke );
}
}
void Konsole::hitDown()
{
TEWidget* te = getTe();
if (te != 0)
{
QKeyEvent ke( QKeyEvent::KeyPress, Qt::Key_Down, 0, 0);
QApplication::sendEvent( te, &ke );
}
}
/**
This function calculates the size of the external widget
needed for the internal widget to be
*/
QSize Konsole::calcSize(int columns, int lines)
{
TEWidget* te = getTe();
if (te != 0)
{
QSize size = te->calcSize(columns, lines);
return size;
}
else
{
QSize size;
return size;
}
}
/**
sets application window to a size based on columns X lines of the te
guest widget. Call with (0,0) for setting default size.
*/
void Konsole::setColLin(int columns, int lines)
{
qDebug("konsole::setColLin:: Columns %d", columns);
if ((columns==0) || (lines==0))
{
if (defaultSize.isEmpty()) // not in config file : set default value
{
defaultSize = calcSize(80,24);
// notifySize(24,80); // set menu items (strange arg order !)
}
resize(defaultSize);
}
else
{
resize(calcSize(columns, lines));
// notifySize(lines,columns); // set menu items (strange arg order !)
}
}
/*
void Konsole::setFont(int fontno)
{
QFont f;
if (fontno == 0)
f = defaultFont = QFont( "Helvetica", 12 );
else
if (fonts[fontno][0] == '-')
f.setRawName( fonts[fontno] );
else
{
f.setFamily(fonts[fontno]);
f.setRawMode( TRUE );
}
if ( !f.exactMatch() && fontno != 0)
{
QString msg = i18n("Font `%1' not found.\nCheck README.linux.console for help.").arg(fonts[fontno]);
QMessageBox(this, msg);
return;
}
if (se) se->setFontNo(fontno);
te->setVTFont(f);
n_font = fontno;
}
*/
// --| color selection |-------------------------------------------------------
void Konsole::changeColumns(int /*columns*/)
{ //FIXME this seems to cause silliness when reset command is executed
// qDebug("change columns");
// TEWidget* te = getTe();
// if (te != 0) {
// setColLin(columns,te->Lines());
// te->update();
// }
}
//FIXME: If a child dies during session swap,
// this routine might be called before
// session swap is completed.
void Konsole::doneSession(TEWidget* te, int )
{
// TEWidget *te = NULL;
// if (sess->currentSession == tab->currentPage()) {
// printf("done current session\n");
// te = getTe();
// } else {
// int currentPage = tab->currentPageIndex();
// printf("done not current session\n");
// for(int i = 0; i < nsessions; i++) {
// tab->setCurrentPage(i);
// printf("find session %d tab page %x session %x\n",
// i, tab->currentPage(), sess->currentSession);
// if (tab->currentPage() == sess->currentSession) {
// printf("found session %d\n", i);
// te = tab->currentPage();
// break;
// }
// }
// tab->setCurrentPage(currentPage);
// }
if (te != 0)
{
te->currentSession->setConnect(FALSE);
tab->removeTab(te);
delete te->currentSession;
delete te;
sessionList->removeItem(nsessions);
nsessions--;
}
if (nsessions == 0)
{
close();
}
}
void Konsole::changeTitle(TEWidget* te, QString newTitle )
{
if (te == getTe())
{
setCaption(newTitle + " - QKonsole");
}
}
void Konsole::newSession()
{
if(nsessions < 15)
{ // seems to be something weird about 16 tabs on the Zaurus.... memory?
TEWidget* te = new TEWidget(tab);
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Menubar");
// FIXME use more defaults from config file
te->useBeep=cfg.readBoolEntry("useBeep",0);
// te->setBackgroundMode(PaletteBase); //we want transparent!!
cfg.setGroup("Font");
QString sn = "Session" + QString::number(nsessions+1);
printf("read font session %s\n", sn.latin1());
QString fontName = cfg.readEntry("FontName"+sn,
cfg.readEntry("FontName",
fonts.at(cfont)->getFamily()));
int fontSize = cfg.readNumEntry("FontSize"+sn,
cfg.readNumEntry("FontSize",
fonts.at(cfont)->getSize()));
cfont = findFont(fontName, fontSize, false);
printf("lookup font %s size %d got %d\n", fontName.latin1(), fontSize, cfont);
if (cfont < 0)
cfont = 0;
te->setVTFont(fonts.at(cfont)->getFont());
tab->addTab(te);
TESession* se = new TESession(this, te, se_pgm, se_args, "xterm");
te->currentSession = se;
connect( se, SIGNAL(done(TEWidget*,int)), this, SLOT(doneSession(TEWidget*,int)) );
connect( se, SIGNAL(changeTitle(TEWidget*,QString)), this,
SLOT(changeTitle(TEWidget*,QString)) );
connect(te, SIGNAL(changeFontSize(int)), this, SLOT(changeFontSize(int)));
connect(te, SIGNAL(changeSession(int)), this, SLOT(changeSession(int)));
connect(te, SIGNAL(newSession()), this, SLOT(newSession()));
connect(te, SIGNAL(toggleFullScreen()), this, SLOT(toggleFullScreen()));
connect(te, SIGNAL(setFullScreen(bool)), this, SLOT(setFullScreen(bool)));
se->run();
se->setConnect(TRUE);
se->setHistory(b_scroll);
nsessions++;
sessionList->insertItem(QString::number(nsessions), nsessions);
sessionListSelected(nsessions);
doWrap();
setColor(nsessions-1);
}
}
TEWidget* Konsole::getTe()
{
if (nsessions)
{
return (TEWidget *) tab->currentPage();
}
else
{
return 0;
}
}
void Konsole::sessionListSelected(int id)
{
if (id < 0)
{
return;
}
QString selected = sessionList->text(id);
EKNumTabBar *tabBar = tab->getTabBar();
int n = 0;
for(int i = 0; n < tabBar->count(); i++)
{
if (tabBar->tab(i))
{
// printf("selected = %s tab %d = %s\n", selected.latin1(),
// i, tabBar->tab(i)->text().latin1());
if (tabBar->tab(i)->text() == selected)
{
tab->setCurrentPage(i);
break;
}
n++;
}
}
}
void Konsole::changeSession(int delta)
{
printf("delta session %d\n", delta);
QTabBar *tabBar = tab->getTabBar();
int i = tabBar->tab(tabBar->currentTab())->text().toInt() - 1;
i += delta;
if (i < 0)
i += tabBar->count();
if (i >= tabBar->count())
i -= tabBar->count();
QString selected = QString::number(i+1);
int n = 0;
for(int i = 0; n < tabBar->count(); i++)
{
if (tabBar->tab(i))
{
printf("selected = %s tab %d = %s\n", selected.latin1(),
i, tabBar->tab(i)->text().latin1());
if (tabBar->tab(i)->text() == selected)
{
tab->setCurrentPage(i);
break;
}
n++;
}
}
}
void Konsole::switchSession(QWidget* w)
{
TEWidget* te = (TEWidget *) w;
QFont teFnt = te->getVTFont();
int familyNum = -1;
for(uint i = 0; i < fonts.count(); i++)
{
VTFont *fnt = fonts.at(i);
bool cf = fnt->getFont() == teFnt;
fontList->setItemChecked(i, cf);
if (cf)
{
cfont = i;
familyNum = fnt->getFamilyNum();
}
}
for(int i = 0; i < (int)fontList->count(); i++)
{
fontList->setItemChecked(i + 1000, i == familyNum);
}
if (! te->currentSession->Title().isEmpty() )
{
setCaption(te->currentSession->Title() + " - QKonsole");
}
else
{
setCaption( "Qkonsole" );
}
// colorMenuSelected(te->color_menu_item);
}
void Konsole::toggleFullScreen()
{
setFullScreen(! fullscreen);
}
void Konsole::setFullScreen ( bool b )
{
static QSize normalsize;
static bool listHidden;
if (b == fullscreen)
{
return;
}
fullscreen = b;
if ( b )
{
if ( !normalsize. isValid ( ))
{
normalsize = size ( );
}
setFixedSize ( qApp-> desktop ( )-> size ( ));
showNormal ( );
reparent ( 0, WStyle_Customize | WStyle_NoBorder,
QPoint ( 0, 0 ));
showFullScreen ( );
menuToolBar->hide();
toolBar->hide();
listHidden = secondToolBar->isHidden();
secondToolBar->hide();
// commonCombo->hide();
tab->getTabBar()->hide();
tab->setMargin(tab->margin());
if (show_fullscreen_msg)
{
fullscreen_msg-> move(tab->x() + tab->width()/2 - fullscreen_msg->width()/2,
qApp->desktop()->height()/16 - fullscreen_msg->height()/2);
fullscreen_msg->show();
fullscreen_timer->start(3000, true);
show_fullscreen_msg = false;
}
}
else
{
showNormal ( );
reparent ( 0, WStyle_Customize, QPoint ( 0, 0 ));
resize ( normalsize );
showMaximized ( );
normalsize = QSize ( );
menuToolBar->show();
toolBar->show();
if(! listHidden)
{
secondToolBar->show();
}
// commonCombo->show();
menuToolBar->show();
if (tabPos != tm_hidden)
{
tab->getTabBar()->show();
}
}
tab->setMargin(tab->margin()); // cause setup to run
}
void Konsole::fullscreenTimeout()
{
fullscreen_msg->hide();
}
void Konsole::colorMenuIsSelected(int iD)
{
fromMenu = TRUE;
colorMenuSelected(iD);
}
/// ------------------------------- some new stuff by L.J. Potter
void Konsole::colorMenuSelected(int iD)
{
// this is NOT pretty, elegant or anything else besides functional
// QString temp;
// qDebug( temp.sprintf("colormenu %d", iD));
TEWidget* te = getTe();
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Colors");
ColorEntry m_table[TABLE_COLORS];
const ColorEntry * defaultCt=te->getdefaultColorTable();
int i;
// te->color_menu_item = iD;
colorMenu->setItemChecked(cm_ab,FALSE);
colorMenu->setItemChecked(cm_bb,FALSE);
colorMenu->setItemChecked(cm_wc,FALSE);
colorMenu->setItemChecked(cm_cw,FALSE);
colorMenu->setItemChecked(cm_mb,FALSE);
colorMenu->setItemChecked(cm_bm,FALSE);
colorMenu->setItemChecked(cm_gy,FALSE);
colorMenu->setItemChecked(cm_rb,FALSE);
colorMenu->setItemChecked(cm_br,FALSE);
colorMenu->setItemChecked(cm_wb,FALSE);
colorMenu->setItemChecked(cm_bw,FALSE);
colorMenu->setItemChecked(cm_gb,FALSE);
if(iD==cm_default)
{ // default default
printf("default colors\n");
for (i = 0; i < TABLE_COLORS; i++)
{
m_table[i].color = defaultCt[i].color;
if(i==1 || i == 11)
m_table[i].transparent=1;
colorMenu->setItemChecked(cm_default,TRUE);
}
te->setColorTable(m_table);
}
if(iD==cm_gb)
{ // green black
foreground.setRgb(100,255,100); // (0x18,255,0x18);
background.setRgb(0x00,0x00,0x00);
colorMenu->setItemChecked(cm_gb,TRUE);
}
if(iD==cm_bw)
{ // black white
foreground.setRgb(0x00,0x00,0x00);
background.setRgb(0xFF,0xFF,0xFF);
colorMenu->setItemChecked(cm_bw,TRUE);
}
if(iD==cm_wb)
{ // white black
foreground.setRgb(0xFF,0xFF,0xFF);
background.setRgb(0x00,0x00,0x00);
colorMenu->setItemChecked(cm_wb,TRUE);
}
if(iD==cm_br)
{// Black, Red
foreground.setRgb(0x00,0x00,0x00);
background.setRgb(255,85,85); //(0xB2,0x18,0x18);
colorMenu->setItemChecked(cm_br,TRUE);
}
if(iD==cm_rb)
{// Red, Black
foreground.setRgb(255,85,85);
background.setRgb(0x00,0x00,0x00);
colorMenu->setItemChecked(cm_rb,TRUE);
}
if(iD==cm_gy)
{// Green, Yellow - is ugly
// foreground.setRgb(0x18,0xB2,0x18);
foreground.setRgb(15,115,0);
// background.setRgb(0xB2,0x68,0x18);
background.setRgb(255,255,0);
colorMenu->setItemChecked(cm_gy,TRUE);
}
if(iD==cm_bm)
{// Blue, Magenta
foreground.setRgb(3,24,132);
background.setRgb(225,2,255);
colorMenu->setItemChecked(cm_bm,TRUE);
}
if(iD==cm_mb)
{// Magenta, Blue
foreground.setRgb(225,2,255);
background.setRgb(3,24,132);
colorMenu->setItemChecked(cm_mb,TRUE);
}
if(iD==cm_cw)
{// Cyan, White
foreground.setRgb(8,91,129);
background.setRgb(0xFF,0xFF,0xFF);
colorMenu->setItemChecked(cm_cw,TRUE);
}
if(iD==cm_wc)
{// White, Cyan
background.setRgb(8,91,129);
foreground.setRgb(0xFF,0xFF,0xFF);
colorMenu->setItemChecked(cm_wc,TRUE);
}
if(iD==cm_bb)
{// Black, Blue
background.setRgb(0x00,0x00,0x00);
foreground.setRgb(127,147,225);
colorMenu->setItemChecked(cm_bb,TRUE);
}
if(iD==cm_ab)
{// Black, Gold
background.setRgb(0x00,0x00,0x00);
foreground.setRgb(255,215,105);
colorMenu->setItemChecked(cm_ab,TRUE);
}
#ifdef QT_QWS_OPIE
if(iD==-19)
{
// Custom
qDebug("do custom");
if(fromMenu)
{
Opie::OColorPopupMenu* penColorPopupMenu = new Opie::OColorPopupMenu(Qt::black, this, "foreground color");
connect(penColorPopupMenu, SIGNAL(colorSelected(const QColor&)), this,
SLOT(changeForegroundColor(const QColor&)));
penColorPopupMenu->exec();
}
if(!fromMenu)
{
foreground.setNamedColor(cfg.readEntry("foreground",""));
background.setNamedColor(cfg.readEntry("background",""));
}
fromMenu=FALSE;
colorMenu->setItemChecked(-19,TRUE);
}
#endif
lastSelectedMenu = iD;
setColors(foreground, background);
QTabBar *tabBar = tab->getTabBar();
QString ss = QString("Session%1").arg(tabBar->currentTab());
// printf("current tab = %d\n", tabBar->currentTab());
if (tabBar->currentTab() == 0)
{
cfg.writeEntry("foregroundRed",QString::number(foreground.red()));
cfg.writeEntry("foregroundGreen",QString::number(foreground.green()));
cfg.writeEntry("foregroundBlue",QString::number(foreground.blue()));
cfg.writeEntry("backgroundRed",QString::number(background.red()));
cfg.writeEntry("backgroundGreen",QString::number(background.green()));
cfg.writeEntry("backgroundBlue",QString::number(background.blue()));
}
cfg.writeEntry("foregroundRed"+ss,QString::number(foreground.red()));
cfg.writeEntry("foregroundGreen"+ss,QString::number(foreground.green()));
cfg.writeEntry("foregroundBlue"+ss,QString::number(foreground.blue()));
cfg.writeEntry("backgroundRed"+ss,QString::number(background.red()));
cfg.writeEntry("backgroundGreen"+ss,QString::number(background.green()));
cfg.writeEntry("backgroundBlue"+ss,QString::number(background.blue()));
update();
}
void Konsole::setColors(QColor foreground, QColor background)
{
int i;
ColorEntry m_table[TABLE_COLORS];
TEWidget* te = getTe();
const ColorEntry * defaultCt=te->getdefaultColorTable();
for (i = 0; i < TABLE_COLORS; i++)
{
if(i==0 || i == 10)
{
m_table[i].color = foreground;
}
else if(i==1 || i == 11)
{
m_table[i].color = background;
m_table[i].transparent=0;
}
else
m_table[i].color = defaultCt[i].color;
}
te->setColorTable(m_table);
}
void Konsole::tabMenuSelected(int id)
{
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Tabs");
tabMenu->setItemChecked(tabPos, false);
if (id == tm_bottom)
{
printf("set bottom tab\n");
tab->getTabBar()->show();
tab->setTabPosition(QTabWidget::Bottom);
tab->getTabBar()->show();
cfg.writeEntry("Position","Bottom");
}
else if (id == tm_top)
{
printf("set top tab\n");
tab->getTabBar()->show();
tab->setTabPosition(QTabWidget::Bottom);
tab->setTabPosition(QTabWidget::Top);
tab->getTabBar()->show();
cfg.writeEntry("Position","Top");
}
else if (id == tm_hidden)
{
tab->getTabBar()->hide();
tab->setMargin(tab->margin());
cfg.writeEntry("Position","Hidden");
}
tabMenu->setItemChecked(id, true);
tabPos = id;
}
void Konsole::configMenuSelected(int iD)
{
// QString temp;
// qDebug( temp.sprintf("configmenu %d",iD));
TEWidget* te = getTe();
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Menubar");
if(iD == cm_wrap)
{
cfg.setGroup("ScrollBar");
bool b=cfg.readBoolEntry("HorzScroll",0);
b=!b;
cfg.writeEntry("HorzScroll", b );
cfg.write();
doWrap();
if(cfg.readNumEntry("Position",2) == 0)
{
te->setScrollbarLocation(1);
}
else
{
te->setScrollbarLocation(0);
}
te->setScrollbarLocation( cfg.readNumEntry("Position",2));
}
if(iD == cm_beep)
{
cfg.setGroup("Menubar");
bool b=cfg.readBoolEntry("useBeep",0);
b=!b;
cfg.writeEntry("useBeep", b );
cfg.write();
configMenu->setItemChecked(cm_beep,b);
te->useBeep=b;
}
}
void Konsole::changeCommand(const QString &text, int c)
{
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Commands");
if(commonCmds[c] != text)
{
cfg.writeEntry(QString::number(c),text);
commonCombo->clearEdit();
commonCombo->setCurrentItem(c);
}
}
void Konsole::setColor(int sess)
{
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Colors");
QColor foreground, background;
QString ss = QString("Session") + QString::number(sess);
foreground.setRgb(cfg.readNumEntry("foregroundRed"+ss,
cfg.readNumEntry("foregroundRed",0xff)),
cfg.readNumEntry("foregroundGreen"+ss,
cfg.readNumEntry("foregroundGreen",0xff)),
cfg.readNumEntry("foregroundBlue"+ss,
cfg.readNumEntry("foregroundBlue",0xff)));
background.setRgb(cfg.readNumEntry("backgroundRed"+ss,
cfg.readNumEntry("backgroundRed",0)),
cfg.readNumEntry("backgroundGreen"+ss,
cfg.readNumEntry("backgroundGreen",0)),
cfg.readNumEntry("backgroundBlue"+ss,
cfg.readNumEntry("backgroundBlue",0)));
setColors(foreground, background);
}
void Konsole::scrollMenuSelected(int index)
{
// qDebug( "scrollbar menu %d",index);
TEWidget* te = getTe();
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("ScrollBar");
if(index == sm_none)
{
te->setScrollbarLocation(0);
cfg.writeEntry("Position",0);
}
else if(index == sm_left)
{
te->setScrollbarLocation(1);
cfg.writeEntry("Position",1);
}
else if(index == sm_right)
{
te->setScrollbarLocation(2);
cfg.writeEntry("Position",2);
}
scrollMenu->setItemChecked(sm_none, index == sm_none);
scrollMenu->setItemChecked(sm_left, index == sm_left);
scrollMenu->setItemChecked(sm_right, index == sm_right);
}
// case -29: {
// bool b=cfg.readBoolEntry("HorzScroll",0);
// cfg.writeEntry("HorzScroll", !b );
// cfg.write();
// if(cfg.readNumEntry("Position",2) == 0) {
// te->setScrollbarLocation(1);
// te->setWrapAt(0);
// } else {
// te->setScrollbarLocation(0);
// te->setWrapAt(120);
// }
// te->setScrollbarLocation( cfg.readNumEntry("Position",2));
// }
// break;
void Konsole::editCommandListMenuSelected(int iD)
{
// QString temp;
// qDebug( temp.sprintf("edit command list %d",iD));
// FIXME: more cleanup needed here
TEWidget* te = getTe();
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Menubar");
if( iD == ec_cmdlist)
{
if(!secondToolBar->isHidden())
{
secondToolBar->hide();
configMenu->changeItem( iD,tr( "Show Command List" ));
cfg.writeEntry("Hidden","TRUE");
configMenu->setItemEnabled(ec_edit ,FALSE);
configMenu->setItemEnabled(ec_quick ,FALSE);
}
else
{
secondToolBar->show();
configMenu->changeItem( iD,tr( "Hide Command List" ));
cfg.writeEntry("Hidden","FALSE");
configMenu->setItemEnabled(ec_edit ,TRUE);
configMenu->setItemEnabled(ec_quick ,TRUE);
if(cfg.readEntry("EditEnabled","FALSE")=="TRUE")
{
configMenu->setItemChecked(ec_edit,TRUE);
commonCombo->setEditable( TRUE );
}
else
{
configMenu->setItemChecked(ec_edit,FALSE);
commonCombo->setEditable( FALSE );
}
}
}
if( iD == ec_quick)
{
cfg.setGroup("Commands");
// qDebug("enableCommandEdit");
if( !configMenu->isItemChecked(iD) )
{
commonCombo->setEditable( TRUE );
configMenu->setItemChecked(iD,TRUE);
commonCombo->setCurrentItem(0);
cfg.writeEntry("EditEnabled","TRUE");
}
else
{
commonCombo->setEditable( FALSE );
configMenu->setItemChecked(iD,FALSE);
cfg.writeEntry("EditEnabled","FALSE");
commonCombo->setFocusPolicy(QWidget::NoFocus);
te->setFocus();
}
}
if(iD == ec_edit)
{
// "edit commands"
CommandEditDialog *m = new CommandEditDialog(this);
connect(m,SIGNAL(commandsEdited()),this,SLOT(initCommandList()));
m->showMaximized();
}
}
// $QPEDIR/bin/qcop QPE/Application/embeddedkonsole 'setDocument(QString)' 'ssh -V'
void Konsole::setDocument( const QString &cmd)
{
newSession();
TEWidget* te = getTe();
if(cmd.find("-e", 0, TRUE) != -1)
{
QString cmd2;
cmd2=cmd.right(cmd.length()-3)+" &";
system(cmd2.latin1());
if(startUp <= 1 && nsessions < 2)
{
doneSession(getTe(), 0);
exit(0);
}
else
doneSession(getTe(), 0);
}
else
{
if (te != 0)
{
te->emitText(cmd+"\r");
}
}
startUp++;
}
// what is the point of this when you can just
// run commands by using the shell directly??
void Konsole::parseCommandLine()
{
QString cmd;
// newSession();
for (int i=1;i< qApp->argc();i++)
{
if( QString(qApp->argv()[i]) == "-e")
{
i++;
for ( int j=i;j< qApp->argc();j++)
{
cmd+=QString(qApp->argv()[j])+" ";
}
cmd.stripWhiteSpace();
system(cmd.latin1());
exit(0);//close();
} // end -e switch
}
startUp++;
}
void Konsole::changeForegroundColor(const QColor &color)
{
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Colors");
int r, g, b;
color.rgb(&r,&g,&b);
foreground.setRgb(r,g,b);
cfg.writeEntry("foreground",color.name());
qDebug("foreground "+color.name());
cfg.write();
qDebug("do other dialog");
#ifdef QT_QWS_OPIE
Opie::OColorPopupMenu* penColorPopupMenu2 = new Opie::OColorPopupMenu(Qt::black, this,"background color");
connect(penColorPopupMenu2, SIGNAL(colorSelected(const QColor&)), this,
SLOT(changeBackgroundColor(const QColor&)));
penColorPopupMenu2->exec();
#endif
}
void Konsole::changeBackgroundColor(const QColor &color)
{
qDebug("Change background");
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("Colors");
int r, g, b;
color.rgb(&r,&g,&b);
background.setRgb(r,g,b);
cfg.writeEntry("background",color.name());
qDebug("background "+color.name());
cfg.write();
}
void Konsole::doWrap()
{
- Config cfg("Qkonsole");
+ Config cfg( "Konsole" );
cfg.setGroup("ScrollBar");
TEWidget* te = getTe();
if( !cfg.readBoolEntry("HorzScroll",0))
{
te->setWrapAt(0);
configMenu->setItemChecked( cm_wrap,TRUE);
}
else
{
// te->setWrapAt(90);
te->setWrapAt(120);
configMenu->setItemChecked( cm_wrap,FALSE);
}
}