void Line::moveCursorTo(int idx)
{
if (idx < 0)
idx = 0;
if (idx > getLength())
idx = getLength();
while (idx > gapstart) {
moveCursorRight();
}
while (idx < gapstart) {
moveCursorLeft();
}
}
void InputReader::moveCursor(char direction) {
switch (direction) {
case 'A':
historyUp();
break;
case 'B':
historyDown();
break;
case 'C':
moveCursorRight();
break;
case 'D':
moveCursorLeft();
break;
default:
break;
}
}
void ArrowNavigationHandler::onKey(ArrowKey direction) {
checkTimeBetweenKeyStrokes(direction);
if (m_throttling[direction])
return;
m_timeStart[direction] = std::chrono::system_clock::now();
switch (direction) {
case ArrowKey::UP:
moveCursorUp();
break;
case ArrowKey::RIGHT:
moveCursorRight();
break;
case ArrowKey::DOWN:
moveCursorDown();
break;
case ArrowKey::LEFT:
moveCursorLeft();
break;
default: break;
}
}
void sdlMapBoucle(sdlMap *sdMap)
{
int continuGame = 1;
int resultMenu;
int i, num;
char c;
Menu menu;
sdlMenuInit(&menu, getSdlMapEcran(sdMap));
//Lancement du menu
resultMenu = sdlMenuBoucle(&menu);
SDL_Event event;
/* Horloges (en secondes) */
float currentClock, prevClock;
/* Intervalle de temps (en secondes) entre deux Èvolutions du jeu */
float intervalClock = 0.1f;
int rafraichissement;
sdlMapAff(sdMap);
assert(SDL_Flip(getSdlMapEcran(sdMap))!=-1);
// RÈcupËre l'horloge actuelle et la convertit en secondes
// clock() retourne le nombre de tops horloge depuis le lancement du programme
prevClock = (float)clock()/(float)CLOCKS_PER_SEC;
// Tant que ce n'est pas la fin ...
while (continuGame == 1)
{
switch (resultMenu)
{
case 0:
continuGame = 0;
resultMenu = 1;
break;
case 2:
num = getMapNum(getSdlMap(sdMap));
num++;
if(num > 4)
num = 1;
setMapNum(getSdlMap(sdMap), num);
setSdlMap(sdMap,newMap(15, 15, num));
setSdlMapMode(sdMap, 0);
setSdlMapSpeed(sdMap, 0);
continuGame = 1;
resultMenu = 1;
break;
default:
break;
}
rafraichissement = 0;
// RÈcupËre l'horloge actuelle et la convertit en secondes
currentClock = (float)clock()/(float)CLOCKS_PER_SEC;
//printf("\n %f \n %f \n %f \n %f \n", horloge_precedente, horloge_courante, (horloge_courante - horloge_precedente), intervalle_horloge);
// Si suffisamment de temps s'est ÈcoulÈ depuis la derniËre prise d'horloge
if ((currentClock - prevClock) >= intervalClock)
{
if (getSdlMapSpeed(sdMap))
{
for (i=0; i<10; i++)
{
updateMap(getSdlMap(sdMap));
}
} else {
for (i=0; i<5; i++)
{
updateMap(sdMap->map);
}
}
updateInterface(getSdlMapInterface(sdMap), getSdlMap(sdMap));
rafraichissement = 1;
prevClock = currentClock;
if(getSdlMap(sdMap)->life <= 0)
{
resultMenu = sdlMenuBoucle(&menu);
}
if(getSdlMapMode(sdMap) && isWaveEnd(getSdlMap(sdMap)))
{
newWave(getSdlMap(sdMap));
}
}
// tant qu'il y a des evenements ‡ traiter : cette boucle n'est pas bloquante
while (SDL_PollEvent(&event))
{
// Si l'utilisateur a cliquÈ sur la croix de fermeture
if ( event.type == SDL_QUIT )
continuGame = 0;
// Si l'utilisateur a appuyÈ sur une touche
if (event.type == SDL_KEYDOWN)
{
rafraichissement = 1;
Map *map = getSdlMap(sdMap);
Interface *interface = getSdlMapInterface(sdMap);
Cursor *cursor = getInterfaceCursor(interface);
switch (event.key.keysym.sym)
{
//Quiter (esc)
case SDLK_ESCAPE:
resultMenu = sdlMenuBoucle(&menu);
break;
//Deplacement curseur droite (left)
case SDLK_LEFT:
moveCursorLeft(cursor);
break;
//Deplacement curseur gauche (right)
case SDLK_RIGHT:
moveCursorRight(cursor);
break;
//Deplacement curseur haut (up)
case SDLK_UP:
moveCursorUp(cursor);
break;
//Deplacement curseur bas (down)
case SDLK_DOWN:
moveCursorDown(cursor);
break;
//Nouvelle vague (w)
case SDLK_w:
if(isWaveEnd(map)){
newWave(map);
}
break;
//Nouvelle tours type archer (a)
case SDLK_a:
buyInterfaceTower('A', &(cursor->position), sdMap->map);
break;
//Nouvelle tours type knight (k)
case SDLK_k:
buyInterfaceTower('K', &(cursor->position), sdMap->map);
break;
//Nouvelle tours type mage (m)
case SDLK_m:
buyInterfaceTower('M', &(cursor->position), sdMap->map);
break;
case SDLK_c:
buyInterfaceTower('C', &(cursor->position), sdMap->map);
break;
case SDLK_e:
if(isCursorOnTower(cursor, getSdlMap(sdMap)))
{
evolveTower(interface->tower, &map->gold);
}
break;
case SDLK_v:
sellInterfaceTower(getSdlMap(sdMap), &(cursor->position), getInterfaceTower(interface));
break;
case SDLK_s:
if (getSdlMapSpeed(sdMap))
{
setSdlMapSpeed(sdMap,0);
} else
{
setSdlMapSpeed(sdMap,1);
}
break;
case SDLK_i:
if(getSdlMapMode(sdMap)){
setSdlMapMode(sdMap,0);
} else {
setSdlMapMode(sdMap,1);
}
break;
default:
break;
}
}
}
if (rafraichissement==1)
{
// on affiche le jeu sur le buffer caché
sdlMapAff(sdMap);
// on permute les deux buffers (cette fonction ne doit se faire qu'une seule fois dans a boucle)
SDL_Flip( getSdlMapEcran(sdMap) );
}
}
sdlMenuLibere(&menu);
}
/////////////////////////////////////////////////////////////////////
// Keyboard Event overrides
/////////////////////////////////////////////////////////////////////
void CFreqCtrl::keyPressEvent( QKeyEvent * event )
{
//call base class if dont over ride key
bool fSkipMsg = FALSE;
qint64 tmp;
//qDebug() <<event->key();
switch(event->key())
{
case Qt::Key_0:
case Qt::Key_1:
case Qt::Key_2:
case Qt::Key_3:
case Qt::Key_4:
case Qt::Key_5:
case Qt::Key_6:
case Qt::Key_7:
case Qt::Key_8:
case Qt::Key_9:
if (m_ActiveEditDigit >= 0)
{
if (m_DigitInfo[m_ActiveEditDigit].editmode)
{
tmp = (m_freq/m_DigitInfo[m_ActiveEditDigit].weight) % 10;
m_freq -= tmp*m_DigitInfo[m_ActiveEditDigit].weight;
m_freq = m_freq+(event->key()-'0')*m_DigitInfo[m_ActiveEditDigit].weight;
setFrequency(m_freq);
}
}
moveCursorRight();
fSkipMsg = TRUE;
break;
case Qt::Key_Left:
if (m_ActiveEditDigit != -1)
{
moveCursorLeft();
fSkipMsg = TRUE;
}
break;
case Qt::Key_Up:
if (m_ActiveEditDigit != -1)
{
incFreq();
fSkipMsg = TRUE;
}
break;
case Qt::Key_Down:
if (m_ActiveEditDigit != -1)
{
decFreq();
fSkipMsg = TRUE;
}
break;
case Qt::Key_Right:
if (m_ActiveEditDigit != -1)
{
moveCursorRight();
fSkipMsg = TRUE;
}
break;
case Qt::Key_Home:
cursorHome();
fSkipMsg = TRUE;
break;
case Qt::Key_End:
cursorEnd();
fSkipMsg = TRUE;
break;
default:
break;
}
if (!fSkipMsg)
QFrame::keyPressEvent(event);
}
string initWriter()
{
string vidmem = (string) 0xb8000;
char oldmem[strlen(vidmem)];
strcpy(oldmem, vidmem);
paintScreen(screen_color);
drawFrame(header_background, 0, 0, 80, 4);
printAt("Q OS Text Editor\r\n", header_foreground, 1, 1);
printAt("Simple Text Editor built for Q OS by Raph Hennessy & Plankp T",desc_foreground,1,2);
drawBorder(screen_background, 0, 4, 80, sh - 1);
cursorY = 5;
cursorX = 1;
updateCursor();
bool inCmdMode = true;
uint16 curX = 1, curY = 5;
uint32 index = 0;
strbuilder_t data = strbuilder_init();
int k;
while(true)
{
cursorX = curX % sw;
cursorY = curY;
updateCursor();
cursorBoundsCheck(&curX, &curY, &index);
printStatus(curX, curY, inCmdMode);
if(inCmdMode)
{
k = waitUntilKey(7, 0x10 /*Q*/, 0x17 /*I*/, 0x18 /*O*/, 0x3A /*<CAPS>*/, 0x23 /*H*/, 0x26 /*L*/, 0x2D /*X*/);
switch(k)
{
case 0x10:
goto end;
case 0x17:
inCmdMode = false;
break;
case 0x18:
appendln(&data, &curX, &curY, &index);
inCmdMode = false;
break;
case 0x23:
moveCursorLeft(&curX, &curY, &index);
break;
case 0x26:
moveCursorRight(&curX, &curY, &index);
break;
case 0x2D:
deleteCharAt(&curX, &curY, &index, &data);
break;
}
} else {
k = getKeycode() / KC_MAGIC_VAL;
char charInput = ' ';
switch(k)
{
case 0x01:
inCmdMode = true;
break;
case 0x1C:
cursorBoundsCheck(&curX, &curY, &index);
appendln(&data, &curX, &curY, &index);
break;
case 0x48:
curY--;
curX = 1;
cursorBoundsCheck(&curX, &curY, &index);
break;
case 0x4B:
moveCursorLeft(&curX, &curY, &index);
break;
case 0x4D:
moveCursorRight(&curX, &curY, &index);
break;
case 0x50:
curY++;
curX = 1;
cursorBoundsCheck(&curX, &curY, &index);
break;
case 0x0E:
deleteCharAt(&curX, &curY, &index, &data);
break;
default:
if(k < 59 && k > 0)
{
charInput = retCorrespChar(kbShiftChars[k], kbLowerChars[k]);
if(charInput == 0)
{
break;
}
insertCharAt(&curX, &curY, &index, &data, charInput);
}
break;
}
}
}
end: // Sorry for the mom spaghetti code
// Must be last line (before any prints)
strcpy(vidmem, oldmem);
string msg = strbuilder_tostr(data);
if(msg == NULL)
{
msg = "";
}
strbuilder_destroy(&data);
cursorX = 1;
cursorY = 5;
print(msg, black);
return msg;
}
bool appl::TextViewer::onEventEntry(const ewol::event::Entry& _event) {
if (m_buffer == nullptr) {
return false;
}
// First call plugin
if (m_pluginManager->onEventEntry(*this, _event) == true) {
markToRedraw();
return true;
}
// just forward event == > manage directly in the buffer
if (_event.getType() == gale::key::keyboard::character) {
//APPL_DEBUG("KB EVENT : \"" << UTF8_data << "\" size=" << strlen(UTF8_data) << "type=" << (int32_t)typeEvent);
if (_event.getStatus() != gale::key::status::down) {
return false;
}
char32_t localValue = _event.getChar();
if (localValue == u32char::Return) {
if (true == _event.getSpecialKey().getShift()) {
localValue = u32char::CarrierReturn;
}
} else if (localValue == u32char::Suppress ) {
//APPL_INFO("keyEvent : <suppr> pos=" << m_cursorPos);
if (m_buffer->hasTextSelected()) {
remove();
} else {
appl::Buffer::Iterator pos = m_buffer->cursor();
appl::Buffer::Iterator posEnd = pos;
++posEnd;
replace("", pos, posEnd);
}
return true;
} else if (localValue == u32char::Delete) {
//APPL_INFO("keyEvent : <del> pos=" << m_cursorPos);
if (m_buffer->hasTextSelected()) {
remove();
} else {
appl::Buffer::Iterator pos = m_buffer->cursor();
appl::Buffer::Iterator posEnd = pos;
--pos;
replace("", pos, posEnd);
}
return true;
}
m_buffer->setSelectMode(false);
// normal adding char ...
char output[5];
output[0] = '0';
u32char::convertUtf8(localValue, output);
if ( m_buffer->hasTextSelected() == false
&& _event.getSpecialKey().getInsert() == true) {
appl::Buffer::Iterator pos = m_buffer->cursor();
appl::Buffer::Iterator posEnd = pos;
++posEnd;
replace(output, pos, posEnd);
//TODO : choisce UTF ... replace(localValue, pos, posEnd);
} else {
std::string myString = output;
write(myString);
}
return true;
}
// move events ...
if (_event.getStatus() == gale::key::status::down) {
// selection when shift is set:
m_buffer->setSelectMode(_event.getSpecialKey().getShift());
// check selection event ...
switch(_event.getType()) {
case gale::key::keyboard::insert:
m_insertMode = m_insertMode==true?false:true;
markToRedraw();
break;
case gale::key::keyboard::left:
//APPL_INFO("keyEvent : <LEFT>");
moveCursorLeft();
break;
case gale::key::keyboard::right:
//APPL_INFO("keyEvent : <RIGHT>");
moveCursorRight();
break;
case gale::key::keyboard::up:
//APPL_INFO("keyEvent : <UP>");
moveCursorUp(1);
break;
case gale::key::keyboard::down:
//APPL_INFO("keyEvent : <DOWN>");
moveCursorDown(1);
break;
case gale::key::keyboard::pageUp:
//APPL_INFO("keyEvent : <PAGE-UP>");
moveCursorUp(15); // TODO : Set the real number of line ...
break;
case gale::key::keyboard::pageDown:
//APPL_INFO("keyEvent : <PAGE-DOWN>");
moveCursorDown(15); // TODO : Set the real number of line ...
break;
case gale::key::keyboard::start:
//APPL_INFO("keyEvent : <Start of line>");
moveCursorLeft(moveEnd);
break;
case gale::key::keyboard::end:
//APPL_INFO("keyEvent : <End of line>");
moveCursorRight(moveEnd);
break;
default:
break;
}
return true;
}
return false;
}
