int new_g15_screen(int screentype)
{
struct sigaction new_sigaction;
int g15screen_fd;
struct sockaddr_in serv_addr;
static int sighandler_init=0;
/* raise the priority of our packets */
int tos = 0x6;
char buffer[256];
if(sighandler_init==0) {
#ifdef HAVE_BACKTRACE
new_sigaction.sa_handler = g15_sighandler;
new_sigaction.sa_flags = 0;
sigaction(SIGSEGV,&new_sigaction,NULL);
#endif
sighandler_init=1;
}
g15screen_fd = socket(AF_INET, SOCK_STREAM, 0);
if (g15screen_fd < 0)
return -1;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
inet_aton (G15SERVER_ADDR, &serv_addr.sin_addr);
serv_addr.sin_port = htons(G15SERVER_PORT);
if (connect(g15screen_fd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)
return -1;
setsockopt(g15screen_fd, SOL_SOCKET, SO_PRIORITY, &tos, sizeof(tos));
if (fcntl(g15screen_fd, F_SETFL, O_NONBLOCK) <0 ) {
}
memset(buffer,0,256);
if(g15_recv(g15screen_fd, buffer, 16)<0)
return -1;
/* here we check that we're really talking to the g15daemon */
if(strcmp(buffer,"G15 daemon HELLO") != 0)
return -1;
if(screentype == G15_TEXTBUF) /* txt buffer - not supported yet */
g15_send(g15screen_fd,"TBUF",4);
else if(screentype == G15_WBMPBUF) /* wbmp buffer */
g15_send(g15screen_fd,"WBUF",4);
else if(screentype == G15_G15RBUF)
g15_send(g15screen_fd,"RBUF",4);
else
g15_send(g15screen_fd,"GBUF",4);
return g15screen_fd;
}
void record_cancel(){
g15r_clearScreen(canvas,G15_COLOR_WHITE);
g15r_renderString (canvas, (unsigned char *)"Recording", 0, G15_TEXT_LARGE, 80-((strlen("Recording")/2)*8), 4);
g15r_renderString (canvas, (unsigned char *)"Canceled", 0, G15_TEXT_LARGE, 80-((strlen("Canceled")/2)*8), 18);
g15_send(g15screen_fd,(char *)canvas->buffer,G15_BUFFER_LEN);
record_cleanup();
}
void processesApplet::update() {
QProcess top;
QString program = "top";
QStringList arguments;
arguments.append("-b");
arguments.append("-n");
arguments.append("1");
top.start(program, arguments);
top.waitForFinished();
QStringList linies = QString(top.readAllStandardOutput()).split("\n");
QStringList procs;
procs.append(linies.at(7));
procs.append(linies.at(8));
procs.append(linies.at(9));
procs.append(linies.at(10));
procs.append(linies.at(11));
QStringList p1 = procs.at(0).split(QRegExp("\\s+"));
QStringList p2 = procs.at(1).split(QRegExp("\\s+"));
QStringList p3 = procs.at(2).split(QRegExp("\\s+"));
QStringList p4 = procs.at(3).split(QRegExp("\\s+"));
QStringList p5 = procs.at(4).split(QRegExp("\\s+"));
if (p1.first() == "") p1.erase(p1.begin());
if (p2.first() == "") p2.erase(p2.begin());
if (p3.first() == "") p3.erase(p3.begin());
if (p4.first() == "") p4.erase(p4.begin());
if (p5.first() == "") p5.erase(p5.begin());
g15r_clearScreen(canvas, 0);
g15r_G15FPrint(canvas, (char *) "Process Monitor", 0, 0, 1, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 0);
g15r_G15FPrint(canvas, qstringToChar(p1.at(0)), 0, 0, 0, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 2);
g15r_G15FPrint(canvas, qstringToChar(p2.at(0)), 0, 0, 0, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 3);
g15r_G15FPrint(canvas, qstringToChar(p3.at(0)), 0, 0, 0, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 4);
g15r_G15FPrint(canvas, qstringToChar(p4.at(0)), 0, 0, 0, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 5);
g15r_G15FPrint(canvas, qstringToChar(p5.at(0)), 0, 0, 0, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 6);
g15r_G15FPrint(canvas, qstringToChar(p1.at(11)), 0, 0, 0, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 2);
g15r_G15FPrint(canvas, qstringToChar(p2.at(11)), 0, 0, 0, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 3);
g15r_G15FPrint(canvas, qstringToChar(p3.at(11)), 0, 0, 0, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 4);
g15r_G15FPrint(canvas, qstringToChar(p4.at(11)), 0, 0, 0, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 5);
g15r_G15FPrint(canvas, qstringToChar(p5.at(11)), 0, 0, 0, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 6);
g15r_G15FPrint(canvas, qstringToChar(p1.at(9)), 0, 0, 0, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 2);
g15r_G15FPrint(canvas, qstringToChar(p2.at(9)), 0, 0, 0, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 3);
g15r_G15FPrint(canvas, qstringToChar(p3.at(9)), 0, 0, 0, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 4);
g15r_G15FPrint(canvas, qstringToChar(p4.at(9)), 0, 0, 0, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 5);
g15r_G15FPrint(canvas, qstringToChar(p5.at(9)), 0, 0, 0, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 6);
g15_send(fd, (char *) canvas->buffer, G15_BUFFER_LEN);
}
// Blasts a single frame onscreen, to the lcd...
//
MODULE_EXPORT void g15_flush (Driver *drvthis)
{
PrivateData *p = drvthis->private_data;
if (memcmp(p->backingstore->buffer, p->canvas->buffer, G15_BUFFER_LEN * sizeof(unsigned char)) == 0)
return;
memcpy(p->backingstore->buffer, p->canvas->buffer, G15_BUFFER_LEN * sizeof(unsigned char));
g15_send(p->g15screen_fd,(char*)p->canvas->buffer,1048);
}
void renderSelectionList()
{
// Draws the three presets in the list (Selected-1,Selected,Selected+1)
// Find config id to render
pthread_mutex_lock(&gui_select);
/*static*/ int tmpRenderConfID = 0;
// Render first entry
if (gui_selectConfig > 0)
tmpRenderConfID = gui_selectConfig-1;
else
tmpRenderConfID = numConfigs;
char* renderLine = stringTrim((char*)getConfigName(tmpRenderConfID),25);
g15r_renderString(canvas, (unsigned char*)renderLine, 0, G15_TEXT_MED, 1, 17);
free(renderLine);
renderLine = NULL;
// Render middle entry available for selection
renderLine = stringTrim((char*)getConfigName(gui_selectConfig),25);
g15r_renderString(canvas, (unsigned char*)renderLine, 0, G15_TEXT_MED, 1, 26);
free(renderLine);
renderLine = NULL;
// Render third (last) entry
if (gui_selectConfig < numConfigs)
tmpRenderConfID = gui_selectConfig+1;
else
tmpRenderConfID = 0;
pthread_mutex_unlock(&gui_select);
renderLine = stringTrim((char*)getConfigName(tmpRenderConfID),25);
g15r_renderString(canvas, (unsigned char*)renderLine, 0, G15_TEXT_MED, 1, 35);
free(renderLine);
renderLine = NULL;
// Make middle look selected by inverting colours
g15r_pixelReverseFill(canvas, 0, 24, 121, 33, 0,G15_COLOR_BLACK);
g15_send(g15screen_fd,(char *)canvas->buffer,G15_BUFFER_LEN);
pthread_mutex_lock(&gui_select);
gui_oldConfig = gui_selectConfig;
pthread_mutex_unlock(&gui_select);
}
void record_complete(unsigned long keystate)
{
char tmpstr[1024];
int gkey = map_gkey(keystate);
pthread_mutex_lock(&config_mutex);
if(!rec_index) // nothing recorded - delete prior recording
memset(mstates[mkey_state]->gkeys[gkey].keysequence.recorded_keypress,0,sizeof(keysequence_t));
else
memcpy(mstates[mkey_state]->gkeys[gkey].keysequence.recorded_keypress, ¤t_recording, sizeof(keysequence_t));
mstates[mkey_state]->gkeys[gkey].keysequence.record_steps=rec_index;
pthread_mutex_unlock(&config_mutex);
g15r_clearScreen(canvas,G15_COLOR_WHITE);
if(rec_index){
strcpy(tmpstr,"For key ");
strcat(tmpstr,gkeystring[map_gkey(keystate)]);
g15macro_log("Recording Complete %s\n",tmpstr);
g15r_renderString (canvas, (unsigned char *)"Recording", 0, G15_TEXT_LARGE, 80-((strlen("Recording")/2)*8), 4);
g15r_renderString (canvas, (unsigned char *)"Complete", 0, G15_TEXT_LARGE, 80-((strlen("Complete")/2)*8), 18);
}else{
strcpy(tmpstr,"From Key ");
printf("%lu\n",keystate);
strcat(tmpstr,gkeystring[map_gkey(keystate)]);
g15macro_log("Macro deleted %s\n",tmpstr);
g15r_renderString (canvas, (unsigned char *)"Macro", 0, G15_TEXT_LARGE, 80-((strlen("Macro")/2)*8), 4);
g15r_renderString (canvas, (unsigned char *)"Deleted", 0, G15_TEXT_LARGE, 80-((strlen("Deleted")/2)*8), 18);
}
g15r_renderString (canvas, (unsigned char *)tmpstr, 0, G15_TEXT_LARGE, 80-((strlen(tmpstr)/2)*8), 32);
g15_send(g15screen_fd,(char *)canvas->buffer,G15_BUFFER_LEN);
record_cleanup();
g15_send_cmd (g15screen_fd,G15DAEMON_MKEYLEDS,mled_state);
save_macros(configpath);
}
void G15LCDDeviceUnix::blitImage(QImage *img, bool) {
Q_ASSERT(img != NULL);
const unsigned int len = 6880;
uchar buf[len];
uchar *tmp = img->bits();
for (unsigned int i = 0; i < len / 8; ++i) {
unsigned int idx = i*8;
buf[idx+7] = tmp[i] & 0x80 ? 1 : 0;
buf[idx+6] = tmp[i] & 0x40 ? 1 : 0;
buf[idx+5] = tmp[i] & 0x20 ? 1 : 0;
buf[idx+4] = tmp[i] & 0x10 ? 1 : 0;
buf[idx+3] = tmp[i] & 0x08 ? 1 : 0;
buf[idx+2] = tmp[i] & 0x04 ? 1 : 0;
buf[idx+1] = tmp[i] & 0x02 ? 1 : 0;
buf[idx+0] = tmp[i] & 0x01 ? 1 : 0;
}
int ret = g15_send(engine->sock, reinterpret_cast<char *>(buf), len);
if (ret < 0)
qWarning("G15LCDDeviceUnix: Unable to g15_send().");
}
/* take the track_info structure and render it */
void *g15display_thread(){
long chksum=0;
static long last_chksum;
int i;
unsigned char time_elapsed[41];
unsigned char time_total[41];
static int current = 0;
int changed =0;
while(!leaving){
if(playlist_mode){
int y=0;
int offset=2;
changed = 0;
if(track_info.currentsong>-1){
current=track_info.currentsong;
track_info.currentsong = -1;
changed = 1;
}
if(playlist_selection>0){
if(current+1<mpd_playlist_get_playlist_length(obj)){
current+=playlist_selection;
changed = 1;
}
playlist_selection=0;
}
if(playlist_selection<0){
if(current) {
current--;
changed = 1;
}
playlist_selection=0;
}
if(current-offset<0)
offset-=current;
if(changed){
g15r_pixelBox (canvas, 0, 0, 159, 42, G15_COLOR_WHITE, 1, 1);
for(i=current-offset;i<current+6;i++){
char title[100];
mpd_Song *song;
song = mpd_playlist_get_song_from_pos(obj, i);
if(song) {
if(song->title!=NULL)
strncpy(title,song->title,99);
else
strncpy(title,"",99);
if(song->artist!=NULL){
strncat(title," - ",99);
strncat(title,song->artist,99);
}
}
/* sanitise the display */
if(i==mpd_playlist_get_playlist_length(obj))
strncpy(title,"End of PlayList",99);
if(i>mpd_playlist_get_playlist_length(obj))
break;
if(i<0)
strncpy(title,"",99);
if(y==offset){
g15r_pixelBox (canvas, 0, 7*offset, 159 , 7*(offset+1), G15_COLOR_BLACK, 1, 1);
canvas->mode_xor=1;
if(song)
if(song->id)
item_selected=song->id;
}
g15r_renderString (canvas, (unsigned char *)title, y, G15_TEXT_MED, 1, 1);
canvas->mode_xor=0;
y++;
}
}
}else{
/* track info */
g15r_pixelBox (canvas, 0, 0, 159, 42, G15_COLOR_WHITE, 1, 1);
g15r_renderString (canvas, (unsigned char *)track_info.artist, 0, G15_TEXT_LARGE, 80-(strlen(track_info.artist)*8)/2, 2);
g15r_renderString (canvas, (unsigned char *)track_info.title, 0, G15_TEXT_MED, 80-(strlen(track_info.title)*5)/2, 12);
/* elapsed time */
memset(time_elapsed,0,41);
memset(time_total,0,41);
if (track_info.total != 0) {
snprintf((char*)time_elapsed,40,"%02i:%02i",track_info.elapsed/60, track_info.elapsed%60);
snprintf((char*)time_total,40,"%02i:%02i",track_info.total/60, track_info.total%60);
}
if(track_info.elapsed>0&&track_info.total>0)
g15r_drawBar (canvas, 10, 22, 149, 30, G15_COLOR_BLACK, track_info.elapsed, track_info.total, 1);
canvas->mode_xor=1;
g15r_renderString (canvas,(unsigned char*)time_elapsed,0,G15_TEXT_MED,12,23);
g15r_renderString (canvas,(unsigned char*)time_total,0,G15_TEXT_MED,124,23);
canvas->mode_xor=0;
switch(track_info.playstate)
{
case MPD_PLAYER_PLAY:
playing=1;
paused=0;
break;
case MPD_PLAYER_PAUSE:
g15r_pixelBox (canvas, 10, 22, 149, 30, G15_COLOR_WHITE, 1, 1);
g15r_renderString (canvas, (unsigned char *)"Playback Paused", 0, G15_TEXT_LARGE, 22, 23);
paused=1;
break;
case MPD_PLAYER_STOP:
g15r_pixelBox (canvas, 10, 22, 149, 30, G15_COLOR_WHITE, 1, 1);
g15r_renderString (canvas, (unsigned char *)"Playback Stopped", 0, G15_TEXT_LARGE, 18, 23);
playing=0;
paused=0;
break;
default:
break;
}
g15r_pixelBox (canvas, 1, 34, 158 , 41, G15_COLOR_WHITE, 1, 1);
g15r_pixelBox (canvas, 10, 34, 27, 42, G15_COLOR_BLACK, 1, 1);
canvas->mode_xor=1;
g15r_renderString (canvas, (unsigned char *)"mode", 0, G15_TEXT_SMALL, 11, 36);
canvas->mode_xor=0;
if(menulevel==MENU_MODE1){
if(track_info.random){
g15r_drawLine (canvas, 43, 42, 158, 42,G15_COLOR_WHITE);
canvas->mode_xor=1;
g15r_pixelBox (canvas, 104, 34, 125 , 42, G15_COLOR_BLACK, 1, 1);
}else{
g15r_pixelBox (canvas, 104, 34, 125 , 42, G15_COLOR_BLACK, 1, 0);
}
g15r_renderString (canvas, (unsigned char *)"Rndm", 0, G15_TEXT_SMALL, 108, 36);
canvas->mode_xor=0;
if(track_info.repeat){
canvas->mode_xor=1;
g15r_pixelBox (canvas, 130, 34, 149 , 42, G15_COLOR_BLACK, 1, 1);
}else {
g15r_pixelBox (canvas, 130, 34, 149 , 42, G15_COLOR_BLACK, 1, 0);
}
g15r_renderString (canvas, (unsigned char *)"Rpt", 0, G15_TEXT_SMALL, 136, 36);
canvas->mode_xor=0;
// 2nd box from left - if you want it...
if(playlist_mode==0){
g15r_pixelBox (canvas, 34, 34, 70 , 42, G15_COLOR_BLACK, 1, 0);
g15r_renderString (canvas, (unsigned char *)"Playlist", 0, G15_TEXT_SMALL, 36, 36);
}else{
canvas->mode_xor=1;
g15r_pixelBox (canvas, 34, 34, 70 , 42, G15_COLOR_BLACK, 1, 1);
g15r_renderString (canvas, (unsigned char *)"Playlist", 0, G15_TEXT_SMALL, 36, 36);
canvas->mode_xor=0;
}
}
if(menulevel==MENU_MODE2){
g15r_pixelBox (canvas, 104, 34, 125 , 42, G15_COLOR_BLACK, 1, 0);
g15r_renderString (canvas, (unsigned char *)"Vol-", 0, G15_TEXT_SMALL, 108, 36);
g15r_pixelBox (canvas, 130, 34, 149 , 42, G15_COLOR_BLACK, 1, 0);
g15r_renderString (canvas, (unsigned char *)"Vol+", 0, G15_TEXT_SMALL, 132, 36);
// 2nd box from left - if you want it...
//g15r_pixelBox (canvas, 34, 34, 54 , 42, G15_COLOR_BLACK, 1, 0);
//g15r_renderString (canvas, (unsigned char *)"test", 0, G15_TEXT_SMALL, 36, 36);
}
if(muted_volume != 0){
g15r_renderString (canvas, (unsigned char *)"MUTE", 0, G15_TEXT_LARGE, 11, 2);
}
else if(voltimeout){
g15r_drawBar (canvas,10, 22, 149, 30, G15_COLOR_BLACK, track_info.volume, 100, 1);
canvas->mode_xor=1;
g15r_renderString (canvas, (unsigned char *)"Volume", 0, G15_TEXT_LARGE, 59, 23);
canvas->mode_xor=0;
}
}
/* do a quicky checksum - only send frame if different */
chksum=0;
for(i=0;i<G15_BUFFER_LEN;i++){
chksum+=canvas->buffer[i]*i;
}
pthread_mutex_lock(&daemon_mutex);
if(last_chksum!=chksum) {
while(g15_send(g15screen_fd,(char *)canvas->buffer,G15_BUFFER_LEN)<0 && !leaving) {
perror("lost connection, tryng again\n");
usleep(10000);
/* connection error occurred - try to reconnect to the daemon */
g15screen_fd=new_g15_screen(G15_G15RBUF);
}
}
pthread_mutex_unlock(&daemon_mutex);
last_chksum=chksum;
usleep(75*1000);
if(playlist_mode)
usleep(75*1000);
}
return NULL;
}
int main(int argc, char **argv)
{
// init vars
have_xtest = False;
numConfigs = 0;
currConfig = 0;
gui_selectConfig = 0;
G15Version = 0;
config_fd = 0;
mled_state = G15_LED_M1;
mkey_state = 0;
recording = 0;
// this is for keeping track of when to redraw
gui_oldConfig = MAX_CONFIGS+1; // To make sure it will be redrawn at first
was_recording = 1;
#ifdef USE_XTEST
int xtest_major_version = 0;
int xtest_minor_version = 0;
#endif
struct sigaction new_action;
int dummy=0,i=0;
unsigned char user[256];
struct passwd *username;
char splashpath[1024];
unsigned int dump = 0;
unsigned int keysonly = 0;
FILE *config;
unsigned int convert = 0;
memset(configDir,0,sizeof(configDir));
strncpy(configDir,getenv("HOME"),1024);
strncat(configDir,"/.g15macro/",1024-strlen(configDir));
strncpy(configpath,getenv("HOME"),1024);
memset(user,0,256);
for(i=0;i<argc;i++){
if (!strncmp(argv[i], "-u",2) || !strncmp(argv[i], "--user",6)) {
if(argv[i+1]!=NULL){
strncpy((char*)user,argv[i+1],128);
i++;
}
}
if (!strncmp(argv[i], "-d",2) || !strncmp(argv[i], "--dump",6)) {
dump = 1;
}
if (!strncmp(argv[i], "-h",2) || !strncmp(argv[i], "--help",6)) {
helptext();
exit(0);
}
if (!strncmp(argv[i], "-k",2) || !strncmp(argv[i], "--keysonly",10)) {
keysonly = 1;
}
if (!strncmp(argv[i], "-g",2) || !strncmp(argv[i], "--debug",7)) {
printf("Debugging Enabled\n");
debug = 1;
}
if (!strncmp(argv[i], "-v",2) || !strncmp(argv[i], "--version",9)) {
printf("G15Macro version %s\n\n",PACKAGE_VERSION);
exit(0);
}
if (!strncmp(argv[i], "-2",2) || !strncmp(argv[i], "--g15version2",13))
{
G15Version = 1; // See declaration for info
}
}
if(strlen((char*)user)){
username = getpwnam((char*)user);
if (username==NULL) {
username = getpwuid(geteuid());
printf("BEWARE: running as effective uid %i\n",username->pw_uid);
}
else {
if(0==setuid(username->pw_uid)) {
setgid(username->pw_gid);
strncpy(configpath,username->pw_dir,1024);
strncpy(configDir,username->pw_dir,1024);
printf("running as user %s\n",username->pw_name);
}
else
printf("Unable to run as user \"%s\" - you dont have permissions for that.\nRunning as \"%s\"\n",username->pw_name,getenv("USER"));
}
printf("BEWARE: this program will run files WITHOUT dropping any kind of privilegies.\n");
}
canvas = (g15canvas *) malloc (sizeof (g15canvas));
if (canvas != NULL) {
g15r_initCanvas(canvas);
} else {
printf("Unable to initialise the libg15render canvas\nExiting\n");
return 1;
}
do {
dpy = XOpenDisplay(getenv("DISPLAY"));
if (!dpy) {
printf("Unable to open display %s - retrying\n",getenv("DISPLAY"));
sleep(2);
}
}while(!dpy);
/* completely ignore errors and carry on */
XSetErrorHandler(myx_error_handler);
// Get keycodes for all keys
strcpy(GKeyCodeCfg,configDir);
strncat(GKeyCodeCfg,"GKeyCodes.cfg",1024-strlen(GKeyCodeCfg));
printf("%s\n",GKeyCodeCfg);
getKeyDefs(GKeyCodeCfg);
configure_mmediakeys();
change_keymap(0);
XFlush(dpy);
if(keysonly>0)
goto close_and_exit;
/* old binary config format */
strncat(configpath,"/.g15macro",1024-strlen(configpath));
strncat(configpath,"/g15macro-data",1024-strlen(configpath));
config_fd = open(configpath,O_RDONLY|O_SYNC);
mstates[0] = malloc(sizeof(mstates_t));
mstates[1] = (mstates_t*)malloc(sizeof(mstates_t));
mstates[2] = (mstates_t*)malloc(sizeof(mstates_t));
if(config_fd>0) {
printf("Converting old data\n");
read(config_fd,mstates[0],sizeof(mstates_t));
read(config_fd,mstates[1],sizeof(mstates_t));
read(config_fd,mstates[2],sizeof(mstates_t));
close(config_fd);
strncpy(configpath,getenv("HOME"),1024);
strncat(configpath,"/.g15macro",1024-strlen(configpath));
char configbak[1024];
strcpy(configbak,configpath);
strncat(configpath,"/g15macro-data",1024-strlen(configpath));
strncat(configbak,"/g15macro-data.old",1024-strlen(configpath));
rename(configpath,configbak);
convert = 1;
}
else
cleanMstates(0); //0 = only NULL the pointers
/* new format */
strncpy(configpath,getenv("HOME"),1024);
strncat(configpath,"/.g15macro",1024-strlen(configpath));
mkdir(configpath,0777);
strncat(configpath,"/g15macro.conf",1024-strlen(configpath));
config=fopen(configpath,"a");
fclose(config);
do {
if((g15screen_fd = new_g15_screen(G15_G15RBUF))<0){
printf("Sorry, cant connect to the G15daemon - retrying\n");
sleep(2);
}
}while(g15screen_fd<0);
loadMultiConfig();
printf("I've now got the following macro files:\n");
for(i=0; i < MAX_CONFIGS;++i)
{
if(!configs[i])
continue;
printf("%i:%s%s\n",i,configDir,configs[i]->configfile);
}
if(!convert)
{
memset(configpath,0,sizeof(configpath));
strcpy(configpath,configDir);
strncat(configpath,configs[currConfig]->configfile,1024-strlen(configpath));
restore_config(configpath);
}
if(dump){
printf("G15Macro Dumping Codes...");
dump_config(stderr);
exit(0);
}
g15_send_cmd (g15screen_fd,G15DAEMON_KEY_HANDLER, dummy);
usleep(1000);
g15_send_cmd (g15screen_fd,G15DAEMON_MKEYLEDS,mled_state);
usleep(1000);
root_win = DefaultRootWindow(dpy);
if (!root_win) {
printf("Cant find root window\n");
return 1;
}
have_xtest = False;
#ifdef HAVE_XTEST
#ifdef USE_XTEST
have_xtest = XTestQueryExtension(dpy, &dummy, &dummy, &xtest_major_version, &xtest_minor_version);
if(have_xtest == False || xtest_major_version < 2 || (xtest_major_version <= 2 && xtest_minor_version < 2))
{
printf("Warning: XTEST extension not supported by Xserver. This is not fatal.\nReverting to XSendEvent for keypress emulation\n");
}
#else //USE_XTEST
printf("XTest disabled by configure option. Using XSendEvent instead.\n");
#endif //USE_XTEST
#else //HAVE_XTEST
printf("XTest disabled by configure: no devel package was found. Using XSendEvent instead.\n");
#endif //HAVE_XTEST
printf("XTest enabled. Using XTest.\n");
new_action.sa_handler = g15macro_sighandler;
new_action.sa_flags = 0;
sigaction(SIGINT, &new_action, NULL);
sigaction(SIGQUIT, &new_action, NULL);
sigaction(SIGTERM, &new_action, NULL);
sigaction(SIGPIPE, &new_action, NULL);
sigaction(SIGHUP, &new_action, NULL);
// So that forked processes that die can actually die instead of going defunct.
struct sigaction act;
memset(&act,0,sizeof(act));
act.sa_handler = &cleanupChildren;
sigaction(SIGCHLD,&act,NULL);
snprintf((char*)splashpath,1024,"%s/%s",DATADIR,"g15macro/splash/g15macro.wbmp");
g15r_loadWbmpSplash(canvas, splashpath);
g15_send(g15screen_fd,(char *)canvas->buffer,G15_BUFFER_LEN);
// Following piece of code is not documented (what i could find anyway)
// But makes so that the user can never bring this screen to front.
// TODO: Document it
// #ifdef G15DAEMON_NEVER_SELECT
// g15_send_cmd (g15screen_fd, G15DAEMON_NEVER_SELECT, dummy);
// #endif
usleep(1000);
pthread_mutex_init(&x11mutex,NULL);
pthread_mutex_init(&config_mutex,NULL);
pthread_mutex_init(&gui_select,NULL);
pthread_attr_t attr;
pthread_attr_init(&attr);
int thread_policy=SCHED_FIFO;
pthread_attr_setschedpolicy(&attr,thread_policy);
pthread_attr_setstacksize(&attr,32*1024); /* set stack to 32k - dont need 8Mb !! */
pthread_create(&Xkeys, &attr, xevent_thread, NULL);
pthread_create(&Lkeys, &attr, Lkeys_thread, NULL);
mainLoop();
cleanup();
close_and_exit:
/* XCloseDisplay(dpy); */
return 0;
}
void xkey_handler(XEvent *event) {
static unsigned long lasttime;
unsigned char keytext[256];
unsigned int keycode = event->xkey.keycode;
int press = True;
if(event->type==KeyRelease){ // we only do keyreleases for some keys
pthread_mutex_lock(&x11mutex);
KeySym key = XKeycodeToKeysym(dpy, keycode, 0);
pthread_mutex_unlock(&x11mutex);
switch (key) {
case XK_Shift_L:
case XK_Shift_R:
case XK_Control_L:
case XK_Control_R:
case XK_Caps_Lock:
case XK_Shift_Lock:
case XK_Meta_L:
case XK_Meta_R:
case XK_Alt_L:
case XK_Alt_R:
case XK_Super_L:
case XK_Super_R:
case XK_Hyper_L:
case XK_Hyper_R:
default:
press = False;
}
}
if(recording){
current_recording.recorded_keypress[rec_index].keycode = keycode;
current_recording.recorded_keypress[rec_index].pressed = press;
current_recording.recorded_keypress[rec_index].modifiers = event->xkey.state;
if(rec_index==0)
current_recording.recorded_keypress[rec_index].time_ms=0;
else
current_recording.recorded_keypress[rec_index].time_ms=g15daemon_gettime_ms() - lasttime;
if(rec_index < MAX_KEYSTEPS)
{
rec_index++;
/* now the default stuff */
pthread_mutex_lock(&x11mutex);
XUngrabKeyboard(dpy,CurrentTime);
pthread_mutex_unlock(&x11mutex);
fake_keyevent(keycode,press,event->xkey.state);
pthread_mutex_lock(&x11mutex);
XGrabKeyboard(dpy, root_win, True, GrabModeAsync, GrabModeAsync, CurrentTime);
XFlush(dpy);
strcpy((char*)keytext,XKeysymToString(XKeycodeToKeysym(dpy, keycode, 0)));
pthread_mutex_unlock(&x11mutex);
if(0==strcmp((char*)keytext,"space"))
strcpy((char*)keytext," ");
if(0==strcmp((char*)keytext,"period"))
strcpy((char*)keytext,".");
if(press==True){
strcat((char*)recstring,(char*)keytext);
g15macro_log("Adding %s to Macro\n",keytext);
g15r_renderString (canvas, (unsigned char *)recstring, 0, G15_TEXT_MED, 80-((strlen((char*)recstring)/2)*5), 22);
g15_send(g15screen_fd,(char *)canvas->buffer,G15_BUFFER_LEN);
}
}
else
{
pthread_mutex_lock(&x11mutex);
XUngrabKeyboard(dpy,CurrentTime);
pthread_mutex_unlock(&x11mutex);
recording = 0;
rec_index = 0;
printf("Saving macro\n");
save_macros(configpath);
}
}
else
rec_index=0;
lasttime = g15daemon_gettime_ms();
}
void *Lkeys_thread() {
unsigned long keystate = 0;
struct pollfd fds;
char ver[5];
int foo = 0;
float g15v;
memset(ver,0x0,sizeof(ver));
strncpy(ver,G15DAEMON_VERSION,3);
sscanf(ver,"%f",&g15v);
g15macro_log("Using version %.2f as keypress protocol\n",g15v);
while(!leaving){
/* g15daemon series 1.2 need key request packets */
if((g15v*10)<=18) {
keystate = g15_send_cmd (g15screen_fd, G15DAEMON_GET_KEYSTATE, foo);
} else {
fds.fd = g15screen_fd;
fds.events = POLLIN;
fds.revents=0;
keystate=0;
if ((poll(&fds, 1, 1000)) > 0) {
read (g15screen_fd, &keystate, sizeof (keystate));
}
}
if (keystate!=0)
{
g15macro_log("Received Keystate == %lu\n",keystate);
switch (keystate)
{
case G15_KEY_L2:
{
int fg_check = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo);
if(!fg_check)
break;
// Go to default/g15macro.conf = id =0
gui_selectChange(0);
break;
}
case G15_KEY_L3:
{
int fg_check = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo);
if(!fg_check)
break;
// Scroll up
gui_selectChange(-1);
break;
}
case G15_KEY_L4:
{
int fg_check = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo);
if(!fg_check)
break;
// Scroll down
gui_selectChange(+1);
break;
}
case G15_KEY_L5:
{
int fg_check = g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo);
if(!fg_check)
break;
// Change to selected
char newConfig[1024];
memset(newConfig,0,sizeof(newConfig));
strcpy(newConfig,configDir);
strncat(newConfig,configs[currConfig]->configfile,sizeof(newConfig)-strlen(newConfig));
// Actually not the newConfig, it's the old, but didn't come up with a good name.
save_macros(newConfig);
// Purge all old data
cleanMstates(1);
// Now load the new config
currConfig = gui_selectConfig;
memset(newConfig,0,sizeof(newConfig));
strcpy(newConfig,configDir);
strncat(newConfig,configs[currConfig]->configfile,sizeof(newConfig)-strlen(newConfig));
restore_config(newConfig);
// Set the configpath to reflect the change
memset(configpath,0,sizeof(configpath));
strcpy(configpath,configDir);
strncat(configpath,configs[currConfig]->configfile,sizeof(configpath)-strlen(configpath));
gui_oldConfig = MAX_CONFIGS+1;
break;
}
case G15_KEY_MR: {
g15macro_log("Key pressed is MR\n");
if(!recording) {
if(0==g15_send_cmd (g15screen_fd, G15DAEMON_IS_FOREGROUND, foo)){
usleep(1000);
g15_send_cmd (g15screen_fd, G15DAEMON_SWITCH_PRIORITIES, foo);
g15macro_log("Switching to LCD foreground\n");
}
usleep(1000);
g15_send_cmd (g15screen_fd,G15DAEMON_MKEYLEDS, G15_LED_MR | mled_state);
g15r_initCanvas (canvas);
g15r_renderString (canvas, (unsigned char *)"Recording", 0, G15_TEXT_LARGE, 80-((strlen("Recording")/2)*8), 1);
g15_send(g15screen_fd,(char *)canvas->buffer,G15_BUFFER_LEN);
g15macro_log("Recording Enabled\n");
recording = 1;
pthread_mutex_lock(&x11mutex);
XGrabKeyboard(dpy, root_win, True, GrabModeAsync, GrabModeAsync, CurrentTime);
pthread_mutex_unlock(&x11mutex);
memset(¤t_recording,0,sizeof(current_recording));
} else {
record_cancel();
g15_send_cmd (g15screen_fd,G15DAEMON_MKEYLEDS,mled_state);
}
break;
}
case G15_KEY_M1:
handle_mkey_switch(G15_KEY_M1);
g15macro_log("Key pressed is M1\n");
break;
case G15_KEY_M2:
handle_mkey_switch(G15_KEY_M2);
g15macro_log("Key pressed is M2\n");
break;
case G15_KEY_M3:
handle_mkey_switch(G15_KEY_M3);
g15macro_log("Key pressed is M3\n");
break;
default:
if(keystate >=G15_KEY_G1 && keystate <=G15_KEY_G18){
if(recording==1){
record_complete(keystate);
} else {
macro_playback(keystate);
}
}
break;
}
keystate = 0;
}
}
return NULL;
}
void hardwareApplet::update() {
g15r_clearScreen(canvas, 0);
unsigned int keystate = 0;
recv(fd, &keystate, 4, 0);
if (keystate) {
if (keystate & G15_KEY_L2) screen = 0;
else if (keystate & G15_KEY_L3) screen = 1;
else if (keystate & G15_KEY_L4) screen = 2;
else if (keystate & G15_KEY_L5) screen = 3;
}
QFile file;
if (screen == 0) {
//CPU
file.setFileName("/proc/stat");
file.open(QIODevice::ReadOnly);
QStringList strcpu = QString(file.readLine()).split(QRegExp("\\s+"));
file.close();
int cpu = strcpu.at(1).toInt() + strcpu.at(2).toInt() + strcpu.at(3).toInt() + strcpu.at(5).toInt();
float diffCpu = cpu - cpuOld;
cpuOld = cpu;
int idle = strcpu.at(4).toInt();
int diffIdle = idle - idleOld;
idleOld = idle;
int progressCpu = diffCpu/(diffCpu+diffIdle)*128;
//MEM
file.setFileName("/proc/meminfo");
file.open(QIODevice::ReadOnly);
QStringList memL1 = QString(file.readLine()).split(QRegExp("\\s+"));
QStringList memL2 = QString(file.readLine()).split(QRegExp("\\s+"));
file.close();
int progressMem = (memL1.at(1).toInt()-memL2.at(1).toInt())/memL1.at(1).toFloat()*128;
g15r_G15FPrint(canvas, (char *) " CPU", 0, 0, 1, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 1);
g15r_pixelBox(canvas, 28, 7, 28+progressCpu, 12, G15_COLOR_BLACK, 1, G15_PIXEL_FILL);
g15r_pixelBox(canvas, 28+progressCpu, 7, 156, 12, G15_COLOR_BLACK, 1, G15_PIXEL_NOFILL);
g15r_G15FPrint(canvas, (char *) " MEM", 0, 0, 1, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 3);
g15r_pixelBox(canvas, 28, 21, 28+progressMem, 26, G15_COLOR_BLACK, 1, G15_PIXEL_FILL);
g15r_pixelBox(canvas, 28+progressMem, 21, 156, 26, G15_COLOR_BLACK, 1, G15_PIXEL_NOFILL);
}
//CPU
else if (screen == 1) {
file.setFileName("/proc/stat");
file.open(QIODevice::ReadOnly);
QStringList strcpu = QString(file.readLine()).split(QRegExp("\\s+"));
file.close();
int user = strcpu.at(1).toInt();
int nice = strcpu.at(2).toInt();
int sys = strcpu.at(3).toInt();
int idle = strcpu.at(4).toInt();
float diffUser = user - userOld;
float diffNice = nice - niceOld;
float diffSys = sys - sysOld;
float diffIdle = idle - idleOld;
float diffTotal = diffUser + diffNice + diffSys + diffIdle;
userOld = user;
niceOld = nice;
sysOld = sys;
idleOld = idle;
QString progressUser = QString::number(std::floor(diffUser/diffTotal*10000)/100).append(" % ");
QString progressNice = QString::number(std::floor(diffNice/diffTotal*10000)/100).append(" % ");
QString progressSys = QString::number(std::floor(diffSys/diffTotal*10000)/100).append(" % ");
QString progressCpu = QString::number(std::floor((diffUser + diffNice + diffSys)/diffTotal*10000)/100).append(" % ");
g15r_G15FPrint(canvas, (char *) " User :"******" Nice :", 24, 4, 1, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 1);
g15r_G15FPrint(canvas, (char *) "System :", 24, 4, 1, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 2);
g15r_G15FPrint(canvas, (char *) " Total :", 24, 4, 1, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 3);
g15r_G15FPrint(canvas, (char *) progressUser.toStdString().c_str(), 0, 4, 1, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 0);
g15r_G15FPrint(canvas, (char *) progressNice.toStdString().c_str(), 0, 4, 1, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 1);
g15r_G15FPrint(canvas, (char *) progressSys.toStdString().c_str(), 0, 4, 1, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 2);
g15r_G15FPrint(canvas, (char *) progressCpu.toStdString().c_str(), 0, 4, 1, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 3);
}
//MEM
else if (screen == 2) {
file.setFileName("/proc/meminfo");
file.open(QIODevice::ReadOnly);
float MemTotal = QString(file.readLine()).split(QRegExp("\\s+"))[1].toInt();
int MemFree = QString(file.readLine()).split(QRegExp("\\s+"))[1].toInt();
int Buffers = QString(file.readLine()).split(QRegExp("\\s+"))[1].toInt();
int Cached = QString(file.readLine()).split(QRegExp("\\s+"))[1].toInt();
file.close();
int progressTotal = 31 + (MemTotal-MemFree)/MemTotal*125;
int progressUsr = 31 + (MemTotal-MemFree-Buffers-Cached)/MemTotal*125;
int progressBuffers = progressUsr + Buffers/MemTotal*125;
int progressCached = progressBuffers + Cached/MemTotal*125;
g15r_G15FPrint(canvas, (char *) " TOTAL", 2, 2, 0, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 0);
g15r_pixelBox(canvas, 31, 2, progressTotal, 6, G15_COLOR_BLACK, 1, G15_PIXEL_FILL);
g15r_pixelBox(canvas, progressTotal, 2, 156, 6, G15_COLOR_BLACK, 1, G15_PIXEL_NOFILL);
g15r_G15FPrint(canvas, (char *) " USER", 4, 4, 0, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 1);
g15r_pixelBox(canvas, 31, 10, progressUsr, 14, G15_COLOR_BLACK, 1, G15_PIXEL_FILL);
g15r_pixelBox(canvas, progressUsr, 10, 156, 14, G15_COLOR_BLACK, 1, G15_PIXEL_NOFILL);
g15r_G15FPrint(canvas, (char *) "BUFFERS", 2, 0, 0, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 3);
g15r_pixelBox(canvas, 31, 18, progressUsr+1, 22, G15_COLOR_BLACK, 1, G15_PIXEL_NOFILL);
g15r_pixelBox(canvas, progressUsr+1, 18, progressBuffers, 22, G15_COLOR_BLACK, 1, G15_PIXEL_FILL);
g15r_pixelBox(canvas, progressBuffers, 18, 156, 22, G15_COLOR_BLACK, 1, G15_PIXEL_NOFILL);
g15r_G15FPrint(canvas, (char *) "CACHED", 3, 2, 0, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 4);
g15r_pixelBox(canvas, 31, 26, progressBuffers+1, 30, G15_COLOR_BLACK, 1, G15_PIXEL_NOFILL);
g15r_pixelBox(canvas, progressBuffers+1, 26, progressCached, 30, G15_COLOR_BLACK, 1, G15_PIXEL_FILL);
g15r_pixelBox(canvas, progressCached, 26, 156, 30, G15_COLOR_BLACK, 1, G15_PIXEL_NOFILL);
}
//NET
else if (screen == 3) {
file.setFileName("/proc/net/dev");
file.open(QIODevice::ReadOnly);
int recvBytes = 0;
int transBytes = 0;
file.readLine();
file.readLine();
while (file.canReadLine()) {
QStringList line = QString(file.readLine()).split(QRegExp("\\s+"));
if (line.at(1) != "lo:") {
recvBytes += line.at(2).toInt();
transBytes += line.at(10).toInt();
}
}
file.close();
float recvVel = (recvBytes-recvBytesOld)*8;
float transVel = (transBytes-transBytesOld)*8;
float recvTotal = recvBytes;
float transTotal = transBytes;
recvBytesOld = recvBytes;
transBytesOld = transBytes;
char recvTotalUnit = 0;
char transTotalUnit = 0;
char recvVelUnit = 0;
char transVelUnit = 0;
while (recvVel >= 1024) {
recvVel /= 1024;
++recvVelUnit;
}
while (transVel >= 1024) {
transVel /= 1024;
++transVelUnit;
}
while (recvTotal >= 1024) {
recvTotal /= 1024;
++recvTotalUnit;
}
while (transTotal >= 1024) {
transTotal /= 1024;
++transTotalUnit;
}
recvVel = std::floor(recvVel*100) / 100;
transVel = std::floor(transVel*100) / 100;
recvTotal = std::floor(recvTotal*100) / 100;
transTotal = std::floor(transTotal*100) / 100;
QString L11 = QString::number(recvVel);
if (recvVelUnit == 0) L11.append(" b/s ");
else if (recvVelUnit == 1) L11.append(" Kb/s ");
else if (recvVelUnit == 2) L11.append(" Mb/s ");
else if (recvVelUnit == 3) L11.append(" Gb/s ");
QString L12 = QString::number(transVel);
if (transVelUnit == 0) L12.append(" b/s ");
else if (transVelUnit == 1) L12.append(" Kb/s ");
else if (transVelUnit == 2) L12.append(" Mb/s ");
else if (transVelUnit == 3) L12.append(" Gb/s ");
QString L21 = QString::number(recvTotal);
if (recvTotalUnit == 0) L21.append(" B ");
else if (recvTotalUnit == 1) L21.append(" KB ");
else if (recvTotalUnit == 2) L21.append(" MB ");
else if (recvTotalUnit == 3) L21.append(" GB ");
QString L22 = QString::number(transTotal);
if (transTotalUnit == 0) L22.append(" B ");
else if (transTotalUnit == 1) L22.append(" KB ");
else if (transTotalUnit == 2) L22.append(" MB ");
else if (transTotalUnit == 3) L22.append(" GB ");
g15r_G15FPrint(canvas, (char *) " RECEIVE TRANSMIT", 0, 2, 1, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 0);
g15r_G15FPrint(canvas, (char *) L11.toStdString().c_str(), 0, 2, 1, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 2);
g15r_G15FPrint(canvas, (char *) L12.toStdString().c_str(), 0, 2, 1, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 2);
g15r_G15FPrint(canvas, (char *) L21.toStdString().c_str(), 0, 2, 1, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 3);
g15r_G15FPrint(canvas, (char *) L22.toStdString().c_str(), 0, 2, 1, G15_JUSTIFY_RIGHT, G15_COLOR_BLACK, 3);
}
g15r_G15FPrint(canvas, (char *) " ALL CPU MEM NET", 0, 0, 1, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 5);
g15_send(fd, (char *) canvas->buffer, G15_BUFFER_LEN);
}
void amarokApplet::update() {
QDBusMessage m = QDBusMessage::createMethodCall((QString)"org.mpris.amarok",(QString)"/Player","",(QString)"GetStatus");
QDBusReply<QRect> result = QDBusConnection::sessionBus().call(m);
g15r_clearScreen(canvas, 0);
if (!result.isValid()) {
g15r_G15FPrint (canvas, (char *) "Amarok", 0, -4, G15_TEXT_HUGE, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 1);
g15r_G15FPrint (canvas, (char *) "Not Running", 0, 0, G15_TEXT_HUGE, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 2);
}
else {
int status = result.value().left();
if (status == 2) g15r_G15FPrint (canvas, (char *) "Stopped", 0, 0, G15_TEXT_LARGE, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 2);
else {
m = QDBusMessage::createMethodCall((QString)"org.mpris.amarok",(QString)"/Player","",(QString)"GetMetadata");
QVariantMap map = QDBusReply<QVariantMap>(QDBusConnection::sessionBus().call(m)).value();
QString title = eliminarAccents(map.find("title").value().toString());
QString artist = eliminarAccents(map.find("artist").value().toString());
QString album = eliminarAccents(map.find("album").value().toString());
QString year = map.find("year").value().toString();
int length = map.find("mtime").value().toInt()/1000;
m = QDBusMessage::createMethodCall((QString)"org.mpris.amarok",(QString)"/Player","",(QString)"PositionGet");
QDBusReply<int> rpos = QDBusConnection::sessionBus().call(m);
int position = rpos.value()/1000;
int totm = length / 60;
int tots = length % 60;
int posm = position / 60;
int poss = position % 60;
int maxlen = std::max(title.length(), std::max(artist.length(), album.length()));
int text_size = G15_TEXT_SMALL;
if (maxlen <= 20) text_size = G15_TEXT_LARGE;
else if (maxlen > 20 && maxlen <= 30) text_size = G15_TEXT_MED;
else {
if (title.length() > 40) title = title.right(title.length()-(poss % (title.length()-38)));
if (artist.length() > 40) artist = artist.right(artist.length()-(poss % (artist.length()-38)));
if (album.length() > 40) album = album.right(album.length()-(poss % (album.length()-38)));
}
QString strtemps;
if (posm < 10) strtemps.append("0");
strtemps.append(QString::number(posm));
strtemps.append(":");
if (poss < 10) strtemps.append("0");
strtemps.append(QString::number(poss));
strtemps.append("/");
if (totm < 10) strtemps.append("0");
strtemps.append(QString::number(totm));
strtemps.append(":");
if (tots < 10) strtemps.append("0");
strtemps.append(QString::number(tots));
int progress = float(position)/float(length)*160;
g15r_G15FPrint (canvas, qstringToChar(title), 0, 0, text_size, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 0);
g15r_G15FPrint (canvas, qstringToChar(artist), 0, 0, text_size, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 1);
g15r_G15FPrint (canvas, qstringToChar(album), 0, 0, text_size, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 2);
g15r_pixelBox(canvas, 0, 28, progress, 32, G15_COLOR_BLACK, 1, G15_PIXEL_FILL);
g15r_pixelBox(canvas, progress, 28, 159, 32, G15_COLOR_BLACK, 1, G15_PIXEL_NOFILL);
g15r_G15FPrint (canvas, qstringToChar(year), 4, 0, G15_TEXT_MED, G15_JUSTIFY_LEFT, G15_COLOR_BLACK, 5);
g15r_G15FPrint (canvas, qstringToChar(strtemps), 0, 0, G15_TEXT_MED, G15_JUSTIFY_CENTER, G15_COLOR_BLACK, 5);
}
}
g15_send(fd, (char *) canvas->buffer, G15_BUFFER_LEN);
}
