/*
Copyright (C) 2002 Paul Wilkins
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/* lcd.c by Paul Wilkins 3/22/97 */
#include <stdio.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "lcd.h"
#include "mode.h"
#include "number.h"
#include "stack.h"
#include "process_input.h"
#include "editor.h"
#include "error.h"
#include "undo.h"
#define FONT1 "12x24"
#define FONT2 "-*-courier-medium-r-*-*-24-*"
#define FONT3 "-misc-fixed-medium-r-normal-*-20-*"
#define FONT4 "10x20"
#define FONT5 "-*-courier-medium-r-*-*-12-*"
#define FONT6 "fixed"
/* the amount of spacing we want around the display */
#define BORDER 2
GtkWidget *lcdDA = NULL;
char **lcdText = NULL;
GdkGC *lcdGC = 0;
GdkGC *lcdHighlightGC = 0;
/* the last area highlighted */
int dataSelected = 0;
int hiX0, hiX1, hiY1;
int hiY0, hiX2, hiY2;
/* font stuff */
GdkFont *lcdFont;
int fontW = 0;
int fontH = 0;
int fontD = 0;
int lcdWidth = 0;
int lcdHeight = 0;
int lcdDisplayMode = LONG_DISPLAY;
int lcdInitalized = 0;
/* some callbacks */
static gint lcdExposeCB(GtkWidget *widget, GdkEventExpose *event);
static gint lcdResizeCB(GtkWidget *widget, GdkEventConfigure *event);
/* local functions */
void calcStackLCD();
void drawStackLCD();
/* this stuff for cut & paste */
#define START_SELECTING 0x1
#define NONE_SELECTED 0x2
#define DATA_SELECTED 0x4
static gint lcdButtonPressEvnt(GtkWidget *widget, GdkEventButton *event);
static gint lcdButtonReleaseEvnt(GtkWidget *widget, GdkEventButton *event);
static gint lcdMotionEvnt(GtkWidget *widget, GdkEventMotion *event);
static gint lcdKeyPressEvnt(GtkWidget *widget, GdkEventKey *event);
static gint lcdKeyReleaseEvnt(GtkWidget *widget, GdkEventKey *event);
void lcdPasteCB(GtkWidget *, GtkSelectionData *, gpointer);
gint loseSelection(GtkWidget *, GdkEventSelection *);
#ifdef GTK_VER_1_1
void convertSelection(GtkWidget *, GtkSelectionData *,
guint, guint, gpointer);
#else
void convertSelection(GtkWidget *, GtkSelectionData *,
gpointer);
#endif
void lcdGetSelection(int time);
void lcdStartHighlight(int x, int y, int time);
void lcdStopHighlight(int x, int y, int time);
void lcdContinueHighlight(int x, int y);
#define TARGET_STRING 0x1
#define TARGET_TEXT 0x2
#define TARGET_COMPOUND_TEXT 0x4
GtkWidget *setupLCD(GtkWidget *parent, int rows, int cols, char *font){
int i;
int width;
int wid, hgt;
#ifdef GTK_VER_1_1
static GtkTargetEntry targetlist[] = {
/* Target Flags Info */
{ "STRING", 0, TARGET_STRING },
{ "TEXT", 0, TARGET_TEXT },
{ "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT }
};
static gint ntargets = sizeof(targetlist) / sizeof(targetlist[0]);
#endif
/* store arguments */
lcdWidth = cols;
lcdHeight = rows;
/* get a font for the main window */
if(font != NULL){
if(NULL == (lcdFont = gdk_font_load(font))){
fprintf(stderr, "Unable to load font %s.\n", font);
exit(0);
}
} else if(NULL == (lcdFont = gdk_font_load(FONT1)) &&
NULL == (lcdFont = gdk_font_load(FONT2)) &&
NULL == (lcdFont = gdk_font_load(FONT3)) &&
NULL == (lcdFont = gdk_font_load(FONT4)) &&
NULL == (lcdFont = gdk_font_load(FONT5)) &&
NULL == (lcdFont = gdk_font_load(FONT6))){
fprintf(stderr, "Unable to load a font.\n");
exit(0);
}
/* find max font width */
for(i=0; i<256; i++){
width = gdk_char_width(lcdFont, (gchar)i);
if(width < 50 && width > fontW) fontW = width;
}
/* globals we use all over the place */
fontH = lcdFont->ascent + lcdFont->descent;
fontD = lcdFont->descent;
if(fontW == 0 || fontH == 0){
fprintf(stderr, "Error: can not determine font dimentions.\n");
exit(0);
}
wid = (2 * BORDER) + (lcdWidth * fontW);
hgt = (2 * BORDER) + (lcdHeight * fontH);
lcdDA = gtk_drawing_area_new();
gtk_drawing_area_size(GTK_DRAWING_AREA(lcdDA), wid, hgt);
gtk_box_pack_start(GTK_BOX(parent), lcdDA, TRUE, TRUE, 0);
gtk_widget_show(lcdDA);
/* Signals used to handle window ops */
gtk_signal_connect(GTK_OBJECT(lcdDA), "expose_event",
(GtkSignalFunc)lcdExposeCB, NULL);
gtk_signal_connect(GTK_OBJECT(lcdDA),"configure_event",
(GtkSignalFunc)lcdResizeCB, NULL);
/* Event signals (Selection) */
gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_received",
(GtkSignalFunc)lcdPasteCB, NULL);
gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_clear_event",
(GtkSignalFunc)loseSelection, NULL);
/*
gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_request_event",
(GtkSignalFunc)convertSelection, NULL);
*/
#ifdef GTK_VER_1_1
gtk_selection_add_targets(lcdDA,
GDK_SELECTION_PRIMARY, targetlist, ntargets);
gtk_signal_connect(GTK_OBJECT(lcdDA), "selection_get",
(GtkSignalFunc)convertSelection, NULL);
#else
gtk_selection_add_handler(lcdDA, GDK_SELECTION_PRIMARY,
GDK_SELECTION_TYPE_STRING, convertSelection, NULL);
#endif
/* Event signals (Input) */
gtk_signal_connect(GTK_OBJECT(lcdDA), "motion_notify_event",
(GtkSignalFunc)lcdMotionEvnt, NULL);
gtk_signal_connect(GTK_OBJECT(lcdDA), "button_press_event",
(GtkSignalFunc)lcdButtonPressEvnt, NULL);
gtk_signal_connect(GTK_OBJECT(lcdDA), "button_release_event",
(GtkSignalFunc)lcdButtonReleaseEvnt, NULL);
gtk_signal_connect_after(GTK_OBJECT(lcdDA), "key_press_event",
(GtkSignalFunc)lcdKeyPressEvnt, NULL);
gtk_signal_connect_after(GTK_OBJECT(lcdDA), "key_release_event",
(GtkSignalFunc)lcdKeyReleaseEvnt, NULL);
gtk_widget_set_events(lcdDA,
GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK |
GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
GTK_WIDGET_SET_FLAGS(lcdDA, GTK_CAN_FOCUS);
gtk_widget_grab_focus(lcdDA);
return lcdDA;
}
void clearLCD(){
/* clear the stack */
clearStack();
/* reset any error string */
resetError();
/* clear the entry buffer */
cancelEditor();
/* re-initialize (and clear) the undo system */
initUndoSystem();
/* redraw the window */
calcStackLCD();
drawStackLCD();
}
void clearLCDwindow(){
gdk_window_clear(lcdDA->window);
}
/* Recalculate the contents of the lcd display.
* note: we don't redraw the lcd here, that is done by drawStackLCD().
*/
void calcStackLCD(){
int i, j;
int strLen, pLen, curPos;
char *c, *p;
char *txt; /* the number */
char label[16]; /* the stack number label */
int height;
int indx;
int row; /* the row to start print the current number */
int txtPos; /* which col do we start printing in */
int lines; /* the number of lines this number has */
int top; /* which row is the top for drawing the stack */
int bottom; /* which row is the current bottom for drawing the stack */
int labelLen; /* the stack number label length */
Number *num;
if(isEditingEditor()){
height = lcdHeight - 1;
} else {
height = lcdHeight;
}
if(height <= 0) return;
/* clear the old display */
for(i=0; i<lcdHeight; i++){
for(j=0; j<lcdWidth; j++){
lcdText[i][j] = ' ';
}
}
/* check for an error */
if(isError()){
top = 1;
c = getStringError();
strLen = strlen(c);
if(strLen > lcdWidth) strLen = lcdWidth;
strncpy(lcdText[0], c, strLen);
} else {
top = 0;
}
bottom = height;
/* print all of the numbers */
for(indx=0; indx<stackLen(); indx++){
/* get the number to print */
if(NULL == (num = getStackEle(indx))) break;
/* get the text of the number */
if(indx == 0 || lcdDisplayMode == LONG_DISPLAY){
if(NULL == (txt = printNumber(num))) break;
} else {
if(NULL == (txt = printNumberShort(num))) break;
}
/* how many lines is this number? */
lines = 1;
for(p=txt; *p!='\0'; p++) if(*p=='\n'){ lines++; *p='\0'; }
/* find the starting line of the number */
row = bottom - lines;
if(row < top) row = top;
/* print the stack number label */
sprintf(label, "%d: ", indx+1);
labelLen = strlen(label);
if(labelLen > lcdWidth) labelLen = lcdWidth;
strncpy(lcdText[row], label, labelLen);
/* print the number */
p = txt;
for(j=0, i=row; i<bottom && j<lines; i++, j++){
pLen = strlen(p);
txtPos = lcdWidth - pLen;
if(txtPos < labelLen) txtPos = labelLen;
if(txtPos > lcdWidth) break;
strncpy(&(lcdText[i][txtPos]), p, lcdWidth-txtPos);
p = p + pLen + 1;
}
/* free the mem used to print the number */
free(txt);
bottom = bottom - j;
if(bottom == top) break;
}
/* fill in the rest of the indexes */
for(i=indx, j=bottom; j>top; i++, j--){
sprintf(label, "%d: ", i+1);
labelLen = strlen(label);
if(labelLen > lcdWidth) labelLen = lcdWidth;
strncpy(lcdText[j-1], label, labelLen);
}
if(isEditingEditor()){
txt = getLineEditor();
curPos = cursorPosEditor();
if(curPos > lcdWidth){
txt += (curPos - lcdWidth);
}
strLen = strlen(txt);
if(strLen > lcdWidth) strLen = lcdWidth;
strncpy(lcdText[lcdHeight-1], txt, strLen);
}
}
/* Redraw the contents of the lcd display.
* note: start BORDER pixels down and to the right.
* TODO: we could be smart and only redraw what has changed.
* This does this work correctly with varriable sized fonts.
*/
void drawStackLCD(){
int i;
int curPos;
int strt, stop;
GdkGC *drawgc;
/* draw the stack */
for(i=0; i<lcdHeight; i++){
/* draw the first unhighlighted section of the line */
strt = 0;
if(dataSelected == DATA_SELECTED && i>=hiY1 && i<=hiY2){
stop = hiX1;
if(stop > lcdWidth) stop = lcdWidth;
} else {
stop = lcdWidth;
}
if(stop-strt){
gdk_window_clear_area(lcdDA->window,
strt*fontW + BORDER, i*fontH + BORDER,
fontW*(stop-strt), fontH);
gdk_draw_text(lcdDA->window, lcdFont, lcdGC,
strt*fontW + BORDER, (i+1)*fontH - fontD + BORDER,
&lcdText[i][strt], stop-strt);
}
/* draw the highlighted section of the line */
if(dataSelected == DATA_SELECTED && i>=hiY1 && i<=hiY2){
strt = hiX1;
if(strt > lcdWidth) strt = lcdWidth;
stop = hiX2+1;
if(stop > lcdWidth) stop = lcdWidth;
if(stop-strt){
gdk_draw_rectangle(lcdDA->window, lcdGC, TRUE,
strt*fontW + BORDER, i*fontH + BORDER,
fontW*(stop-strt), fontH);
gdk_draw_text(lcdDA->window, lcdFont, lcdHighlightGC,
strt*fontW + BORDER, (i+1)*fontH - fontD + BORDER,
&lcdText[i][strt], stop-strt);
}
}
/* draw the last unhighlighted section of the line */
stop = lcdWidth;
if(dataSelected == DATA_SELECTED && i>=hiY1 && i<=hiY2){
strt = hiX2+1;
if(strt > lcdWidth) strt = lcdWidth;
} else {
strt = lcdWidth;
}
if(stop-strt){
gdk_window_clear_area(lcdDA->window,
strt*fontW + BORDER, i*fontH + BORDER,
fontW*(stop-strt), fontH);
gdk_draw_text(lcdDA->window, lcdFont, lcdGC,
strt*fontW + BORDER, (i+1)*fontH - fontD + BORDER,
&lcdText[i][strt], stop-strt);
}
}
/* draw the cursor */
if(isEditingEditor()){
curPos = cursorPosEditor();
if(curPos > lcdWidth){
curPos = lcdWidth;
}
if(dataSelected == DATA_SELECTED &&
curPos>=hiX1 && curPos<=hiX2 &&
lcdHeight-1>=hiY1 && lcdHeight-1<=hiY2)
{
drawgc = lcdHighlightGC;
} else {
drawgc = lcdGC;
}
/* hack: draw a white line to erase any old cursor
in position 0. XDrawImageString dosen't cover this
up like it does with an old cursor in any other position */
if(!(dataSelected == DATA_SELECTED &&
0==hiX1 && lcdHeight-1>=hiY1 && lcdHeight-1<=hiY2))
{
gdk_draw_line(lcdDA->window, lcdHighlightGC,
BORDER - 1, (lcdHeight-1) * fontH + BORDER,
BORDER - 1, lcdHeight * fontH - 1 + BORDER);
}
/* draw the cursor */
gdk_draw_line(lcdDA->window, drawgc,
fontW * curPos - 1 + BORDER, (lcdHeight-1) * fontH + BORDER,
fontW * curPos - 1 + BORDER, lcdHeight * fontH - 1 + BORDER);
}
}
/* redraw what we need to */
void redrawLCD(){
calcStackLCD();
drawStackLCD();
}
void lcdResize(){
int i;
char *buf;
int width, height;
width = lcdDA->allocation.width;
height = lcdDA->allocation.height;
lcdWidth = (width - 2*BORDER) / fontW;
if(lcdWidth < 0) lcdWidth = 0;
lcdHeight = (height - 2*BORDER) / fontH;
if(lcdHeight < 0) lcdHeight = 0;
/* free the old mem */
if(lcdText){
free(lcdText[0]);
free(lcdText);
}
/* get the new mem. note: add 1 bec size could otherwize be 0. */
if(NULL == (lcdText=(char**)malloc((1+lcdHeight)*sizeof(char *)))){
perror("malloc");
exit(0);
}
if(NULL == (buf=(char*)malloc(1+lcdHeight*lcdWidth*sizeof(char)))){
perror("malloc");
exit(0);
}
lcdText[0] = buf; /* in case lcdHeight == 0 */
for(i=0; i<lcdHeight; i++){
lcdText[i] = &buf[lcdWidth * i];
}
/* we don't get an expose if the window shrinks */
clearLCDwindow();
calcStackLCD();
drawStackLCD();
}
void setLCDDispMode(int val){
if(val == LONG_DISPLAY) lcdDisplayMode = LONG_DISPLAY;
else if(val == SHORT_DISPLAY) lcdDisplayMode = SHORT_DISPLAY;
else printf("setShortLCD invalid mode\n");
}
int getLCDDispMode(){
return lcdDisplayMode;
}
static gint lcdExposeCB(GtkWidget *widget, GdkEventExpose *event){
GtkStyle *style;
if(lcdInitalized == 0){
style = gtk_widget_get_style(widget);
/* Set the default Graphics Contexts */
/* highlight swaps foreground and background */
lcdGC = style->fg_gc[GTK_STATE_NORMAL];
lcdHighlightGC = style->bg_gc[GTK_STATE_NORMAL];
lcdResize();
lcdInitalized = 1;
}
clearLCDwindow();
drawStackLCD();
return FALSE;
}
static gint lcdResizeCB(GtkWidget *widget, GdkEventConfigure *event){
if(lcdInitalized != 0) lcdResize();
return TRUE;
}
static gint lcdKeyPressEvnt(GtkWidget *widget, GdkEventKey *event){
char c;
if(event->string) c = *(event->string);
else c = 'd'; /* just pick something */
processInput(
event->keyval,
event->state & GDK_CONTROL_MASK ? 1 : 0,
c,
'd');
return TRUE;
}
static gint lcdKeyReleaseEvnt(GtkWidget *widget, GdkEventKey *event){
return TRUE;
}
static gint lcdButtonPressEvnt(GtkWidget *widget, GdkEventButton *event) {
gtk_widget_grab_focus(lcdDA);
if(event->button == 1){
lcdStartHighlight(event->x, event->y, event->time);
}
}
static gint lcdButtonReleaseEvnt(GtkWidget *widget, GdkEventButton *event) {
switch(event->button){
case 1: /* stop highlighting an area */
lcdStopHighlight(event->x, event->y, event->time);
break;
case 2: /* paste data */
lcdGetSelection(event->time);
break;
case 3: /* might be used to continue highlighting */
if(dataSelected == DATA_SELECTED){
lcdContinueHighlight(event->x, event->y);
lcdStopHighlight(event->x, event->y, event->time);
}
break;
}
}
static gint lcdMotionEvnt(GtkWidget *widget, GdkEventMotion *event)
{
int x, y;
GdkModifierType state;
if(event->is_hint){
gdk_window_get_pointer(event->window, &x, &y, &state);
} else {
x = event->x;
y = event->y;
state = event->state;
}
if(state & GDK_BUTTON1_MASK){
/* highlighting with button 1 */
lcdContinueHighlight(x, y);
} else if(state & GDK_BUTTON3_MASK &&
dataSelected == DATA_SELECTED){
/* continuing a highlight with button 3 */
lcdContinueHighlight(x, y);
}
return TRUE;
}
#ifdef GTK_VER_1_1
void convertSelection(
GtkWidget *widget,
GtkSelectionData *selection,
guint info,
guint time,
gpointer data)
#else
void convertSelection(
GtkWidget *widget,
GtkSelectionData *selection,
gpointer data)
#endif
{
int i;
int width, height;
char *str;
guchar *text;
gint len;
gint format;
GdkAtom type;
/* no highlight */
if(dataSelected != DATA_SELECTED){
printf("convertSelection called, but no selection.\n");
} else {
width = hiX2 - hiX1 + 1;
height = hiY2 - hiY1 + 1;
len = (width + 1) * height;
str = (char *)malloc(len * sizeof(char));
for(i=0; i<height; i++){
strncpy(str+(i*(width+1)), &(lcdText[i+hiY1][hiX1]), width);
*(str+(i*(width+1))+width) = '\n';
}
str[len-1] = '\0';
#ifdef GTK_VER_1_1
switch(info){
#else
switch(selection->target){
#endif
case GDK_TARGET_STRING:
case TARGET_STRING:
gtk_selection_data_set(
selection,
GDK_SELECTION_TYPE_STRING,
8,
str,
len-1);
break;
case TARGET_TEXT:
case TARGET_COMPOUND_TEXT:
gdk_string_to_compound_text(str,
&type, &format, &text, &len);
gtk_selection_data_set(
selection,
type,
format,
text,
len);
gdk_free_compound_text(text);
break;
}
}
}
gint loseSelection(
GtkWidget *widget,
GdkEventSelection *event)
{
/* if there is a current (old) selection, then clear it */
if(dataSelected == DATA_SELECTED){
dataSelected = NONE_SELECTED;
drawStackLCD();
}
return TRUE;
}
void lcdStartHighlight(int x, int y, int time){
int xx, yy;
/* if there is a current (old) selection, then clear it */
if(dataSelected == DATA_SELECTED){
dataSelected = NONE_SELECTED;
drawStackLCD();
/* ... and tell GDK */
if(gdk_selection_owner_get(GDK_SELECTION_PRIMARY) == lcdDA->window){
gtk_selection_owner_set(NULL,
GDK_SELECTION_PRIMARY,
GDK_CURRENT_TIME);
}
}
xx = (x - BORDER) / fontW;
if(xx < 0) xx = 0;
if(xx >= lcdWidth) xx = lcdWidth - 1;
yy = (y - BORDER) / fontH;
if(yy < 0) yy = 0;
if(yy >= lcdHeight) yy = lcdHeight - 1;
hiX0 = hiX1 = hiX2 = xx;
hiY0 = hiY1 = hiY2 = yy;
dataSelected = START_SELECTING;
}
void lcdStopHighlight(int x, int y, int time){
int reCalc, curPos;
int xx, yy;
/* if the user started to select something, but didn't actually
select anything, then reset stuff */
if(dataSelected == START_SELECTING){
dataSelected = NONE_SELECTED;
/* user may have been positioning the edit cursor */
if(isEditingEditor()){
xx = (x - BORDER) / fontW;
if(xx < 0) xx = 0;
if(xx >= lcdWidth) xx = lcdWidth - 1;
yy = (y - BORDER) / fontH;
if(yy == lcdHeight-1){
curPos = cursorPosEditor();
if(curPos > lcdWidth){
reCalc = 1;
xx += (curPos - lcdWidth);
} else {
reCalc = 0;
}
setCursorPosEditor(xx);
/* need to recalc since cursor may have moved out of the
visable part of the editor */
if(reCalc) calcStackLCD();
}
}
/* clear any old highlights */
drawStackLCD();
}
/* if data is now selected */
if(dataSelected == DATA_SELECTED){
if(0 == gtk_selection_owner_set(
lcdDA,
GDK_SELECTION_PRIMARY,
GDK_CURRENT_TIME))
{
fprintf(stderr, "failed to gain selection\n");
dataSelected = NONE_SELECTED;
drawStackLCD();
}
}
}
void lcdContinueHighlight(int x, int y){
int xx, yy;
int lastx1, lastx2, lasty1, lasty2;
xx = (x - BORDER) / fontW;
if(xx < 0) xx = 0;
if(xx >= lcdWidth) xx = lcdWidth - 1;
yy = (y - BORDER) / fontH;
if(yy < 0) yy = 0;
if(yy >= lcdHeight) yy = lcdHeight - 1;
lastx1 = hiX1;
lastx2 = hiX2;
lasty1 = hiY1;
lasty2 = hiY2;
if(xx < hiX0){
hiX1 = xx;
hiX2 = hiX0 + 0;
} else {
hiX1 = hiX0;
hiX2 = xx + 0;
}
if(yy < hiY0){
hiY1 = yy;
hiY2 = hiY0 + 0;
} else {
hiY1 = hiY0;
hiY2 = yy + 0;
}
/* if the highlight area changed */
if(lastx1 != hiX1 || lastx2 != hiX2 || lasty1 != hiY1 || lasty2 != hiY2){
dataSelected = DATA_SELECTED;
/* repaint the display */
drawStackLCD();
}
}
/* ask for data */
void lcdGetSelection(int time){
/* And request the primary selection */
gtk_selection_convert(lcdDA,
GDK_SELECTION_PRIMARY, /* GdkAtom selection */
GDK_TARGET_STRING, /* GdkAtom target */
GDK_CURRENT_TIME); /* guint32 time */
}
void lcdPasteCB(
GtkWidget *widget,
GtkSelectionData *selection,
gpointer data)
{
int i;
char *str;
static GdkAtom clipboard_atom = GDK_NONE;
if(selection->length <= 0 ||
selection->type != GDK_SELECTION_TYPE_STRING){
/* printf("length is zero or did not get a string.\n"); */
if(selection->selection != GDK_SELECTION_PRIMARY) return;
/* selection failed. Try the clipboard now... */
if(clipboard_atom == GDK_NONE){
clipboard_atom = gdk_atom_intern("CLIPBOARD", FALSE);
}
/* ask for another selection, but this time from the clipboard */
gtk_selection_convert(lcdDA,
clipboard_atom, /* GdkAtom selection */
GDK_TARGET_STRING, /* GdkAtom target */
GDK_CURRENT_TIME); /* guint32 time */
return;
}
str = (char*)selection->data;
for(i=0; i<selection->length; i++){
/* TODO maybe do something like isalpha() here? */
processInput(0, 0, str[i], str[i]);
}
}
syntax highlighted by Code2HTML, v. 0.9.1