pmusa
/
luamemprofiler
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
luamemprofiler/vmemory.c

708 lines
22 KiB
C
Raw Permalink Blame History

/*
**
** Author: Pablo Musa
** Creation Date: mar 27 2011
** Last Modification: aug 22 2011
** See Copyright Notice in COPYRIGHT
**
** See vmemory.h for module overview
**
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <lualib.h>
#include <math.h>
#include <stdint.h>
#include "graphic.h"
#include "vmemory.h"
#include "lmp_struct.h"
#include "lmp.h"
#define WINDOW_TITLE "luamemprofiler v1.0"
#define ICON_PATH "logo.bmp"
/* screen state */
#define LMP_PAUSE 0
#define LMP_EXEC 1
#define LMP_FINISH -1
#define LMP_ZOOM_OUT 0
#define LMP_ZOOM_IN 1
#define MIN_mb_SIZE 1
#define MIN_mb_WIDTH 800
#define MIN_mb_HEIGHT 600
#define BOX_XINI 10 /* MINIMUM = 10 */
#define BOX_YINI 10 /* MINIMUM = 10 */
#define BOX_XEND (mb_width + BOX_XINI)
#define BOX_YEND (mb_height + BOX_YINI)
#define RTCOLUMN_WIDTH 150 /* right column width */
#define BTROW_HEIGHT 70 /* bottom row height */
#define BASE_SPACE 10 /* space for separating text from the box */
#define BOX_BORDER 3 /* memory box border width */
#define LMP_FLINE 0 /* bottom row starts writing in first line (0) */
#define LMP_ON 1
#define LMP_OFF 0
/* filter type menu - positions to draw, bool toggled, draw Color, and text */
struct menuitem {
int x;
int y;
int toggle;
Color color;
const char *name;
};
typedef struct menuitem LMP_Menuitem;
/* GLOBAL VARIABLES */
/* one block list for each filter type */
extern lmp_Block *lmp_string;
extern lmp_Block *lmp_function;
extern lmp_Block *lmp_userdata;
extern lmp_Block *lmp_thread;
extern lmp_Block *lmp_table;
extern lmp_Block *lmp_other;
extern lmp_Block *lmp_all;
/* one menu for each filter type */
static LMP_Menuitem mi_string;
static LMP_Menuitem mi_function;
static LMP_Menuitem mi_userdata;
static LMP_Menuitem mi_thread;
static LMP_Menuitem mi_table;
static LMP_Menuitem mi_other;
/* STATIC GLOBAL VARIABLES */
static Screen *screen;
static uintptr_t laddress; /* first address of the program */
static uintptr_t baseaddr; /* base address of the memory box */
static int state = LMP_PAUSE; /* luamemprofiler state (paused or executing) */
static int zoom = LMP_ZOOM_OUT; /* zoom state (in or out) */
static int sc_width; /* sc = screen */
static int sc_height;
static int mb_width; /* mb = memory box */
static int mb_height;
static int BYTES_PER_PIXEL = 4;
static int BLOCK_HEIGHT = 2;
static int statesy; /* used to update the display with state and zoom */
/* STATIC FUNCTIONS */
static void drawbtrow();
static void toggleall();
static void drawstates();
static void drawmembox();
static void checkevent();
static void clearmembox();
static void untoggleall();
static int istoggled(size_t luatype);
static void drawcallstack(int fline);
static void drawrtcolumn(float memused);
static int setcanvassize (float memused);
static void inverttoggle(LMP_Menuitem *mi);
static void drawmenuitem(LMP_Menuitem *item);
static void drawreport(const char *text, int line);
static void drawmemblock(int addr, size_t luatype, size_t size);
static void writeblockinfo(void *ptr,size_t luatype,size_t size,int alloctype);
static void calcmemdata(void *ptr, size_t size, int *reladdr, size_t *relsize);
static void initmenuitem(LMP_Menuitem *mi, int x, int y, int toggle,
Color color, const char* name);
/* GLOBAL FUNCTIONS */
void vm_start(int lowestaddress, float memused) {
/* if memused is very low uses default value and returns it */
memused = setcanvassize (memused);
screen = gr_newscreen(sc_width, sc_height, ICON_PATH, WINDOW_TITLE);
laddress = lowestaddress;
baseaddr = laddress;
gr_drawbackground(screen, LMP_VM_BACKGROUND_CL);
drawmembox();
drawrtcolumn(memused);
drawbtrow();
checkevent();
}
void vm_stop() {
char dummy;
state = LMP_FINISH;
drawreport("Execution finished. The report is in the Terminal.", LMP_FLINE);
drawstates();
printf("Press Enter To Finish!");
scanf("%c", &dummy);
gr_destroyscreen(screen);
}
void vm_newmemop(int memop, void *ptr, size_t luatype, size_t size) {
int p;
size_t mb_size;
calcmemdata(ptr, size, &p, &mb_size); /* calculate relative address */
if (p > 0) { /* check if is a valid address */
/* draw full block breaking lines if necessary */
if (istoggled(luatype))
drawmemblock(p, luatype, mb_size);
if (state == LMP_PAUSE) {
/* write in 'bottom row' block information(parameters) and call stack */
writeblockinfo(ptr, luatype, size, memop);
}
/* check if there is any valid event and treat it */
checkevent();
}
/* DEBUG else { possible print if block is smaller than baseaddress
printf("Lower Pointer ptr=%d laddr=%d p=%d\n", (int) ptr, laddress, p);
} */
}
/* STATIC FUNCTIONS */
/* uses baseaddress to calculate the memory box position of a block */
static void calcmemdata(void *ptr, size_t size, int *reladdr, size_t *relsize) {
*reladdr = ((uintptr_t) ptr - baseaddr) / BYTES_PER_PIXEL;
*relsize = (size / BYTES_PER_PIXEL);
if (*relsize == 0) {
*relsize = 1;
}
}
/* draw specified text in report area (botton row) */
static void drawreport(const char *text, int line) {
int x = BOX_XINI;
int y = BOX_YEND + BASE_SPACE + (line * gr_gettextheight(screen));
/* if line does not fit screen size, omit line */
if (y > sc_height - gr_gettextheight(screen)) {
return;
}
/* if line is first line, new message -> clear bottom row */
if (line == LMP_FLINE) {
gr_setdrawcolor(screen, LMP_VM_BACKGROUND_CL);
gr_drawblock(screen, BOX_XINI, BOX_XEND, BOX_YEND+BASE_SPACE, BTROW_HEIGHT);
}
/* validate text size */
if (strlen(text) > (mb_width / gr_gettextwidth(screen))) {
gr_drawtext(screen, "Sorry, but the text is too large.", x, y);
} else {
gr_drawtext(screen, text, x, y);
}
}
/* draw up to 3 levels of the call stack */
static void drawcallstack(int fline) {
char textbuff[80] = "";
int res, i = 0;
lua_Debug ld;
lua_State *L = (lua_State *) laddress;
res = lua_getstack(L, i, &ld);
while (res == 1 && i < (BTROW_HEIGHT/gr_gettextwidth(screen))) {
int r;
r = lua_getinfo(L, "lnS", &ld);
if (r != 0) {
int line = LMP_FLINE + i + fline; /* start in fline */
if (strcmp(ld.what, "main") == 0) { /* main program execution */
sprintf(textbuff, "Main - line:%d", ld.currentline);
drawreport(textbuff, line);
break;
}
if (strcmp(ld.what, "Lua") == 0) { /* some function execution */
sprintf(textbuff, "Lua - file:'%s' func:'%s' field:'%s' line:%d",
ld.short_src, ld.name, ld.namewhat, ld.currentline);
drawreport(textbuff, line);
}
if (strcmp(ld.what, "C") == 0) { /* some C function execution */
sprintf(textbuff, "C - func'%s' field:'%s'", ld.name, ld.namewhat);
drawreport(textbuff, line);
}
} else {
printf("luamemprofiler internal error: vmemory -> debuginfo -> invalid what.\n");
exit(EXIT_FAILURE);
}
i++;
res = lua_getstack(L, i, &ld);
}
}
/* draw blocks in the correct place (recursive calls for big blocks) */
static void drawmemblock(int addr, size_t luatype, size_t size) {
int x, y;
x = (addr % mb_width) + BOX_XINI;
y = ((addr / mb_width) * BLOCK_HEIGHT) + BOX_YINI;
/* just draw into valid areas */
if (y >= BOX_YINI && (y + BLOCK_HEIGHT) <= BOX_YEND) {
if (x + size > BOX_XEND){ /* break block to fit membox */
size_t extrasize = size - (BOX_XEND + 1 - x); /* +1 -> XEND is valid */
size = size - extrasize;
/* recursive call for breaking one block in different lines */
drawmemblock(addr + (size - 1), luatype, extrasize); /* -1 -> XEND */
}
switch(luatype) {
case LUA_TSTRING:
gr_setdrawcolor(screen, LMP_VM_STRING_CL);
break;
case LUA_TFUNCTION:
gr_setdrawcolor(screen, LMP_VM_FUNCTION_CL);
break;
case LUA_TUSERDATA:
gr_setdrawcolor(screen, LMP_VM_USERDATA_CL);
break;
case LUA_TTHREAD:
gr_setdrawcolor(screen, LMP_VM_THREAD_CL);
break;
case LUA_TTABLE:
gr_setdrawcolor(screen, LMP_VM_TABLE_CL);
break;
case LUA_TFREE:
gr_setdrawcolor(screen, LMP_VM_FREE_CL);
break;
default:
gr_setdrawcolor(screen, LMP_VM_OTHER_CL);
}
/* block length is size, so draw from x to "size-1" */
gr_drawblock(screen, x, x + size - 1, y, BLOCK_HEIGHT);
}
/* DEBUG else { possible use when all blocks have to be drawn
printf("draw block (%d, %d) addr = %d\n", x, y, addr); } */
}
/*
** traverse a filter list drawing all blocks. 'block' is the first block in the
** list and 'fnextblock' is a function that returns the next block in the list
** or NULL
*/
void drawblocklist(lmp_Block *block, lmp_Block* (*fnextblock) (lmp_Block*)) {
int p;
size_t mb_size;
while (block != NULL) { /* list is not empty */
calcmemdata(block->ptr, st_getsize(block), &p, &mb_size);
if (p > 0) {
int luatype = istoggled(block->luatype) ? block->luatype : LUA_TFREE;
drawmemblock(p, luatype, mb_size);
}
block = fnextblock(block);
}
}
/*
** redraw blocks using bigger size and new baseaddress. The new base address is
** calculated using 'y' coordinate. All blocks above this 'y' (y included) are
** redrawn.
*/
static void zoomin(int x, int y) {
int p;
size_t mb_size;
lmp_Block *block;
zoom = LMP_ZOOM_IN; /* change zoom state */
drawstates(); /* update display with new state */
clearmembox(); /* clear memory box for new blocks in zoom mode */
/* calculates baseaddress using old baseaddress and 'y' */
baseaddr = (((y - BOX_YINI) / BLOCK_HEIGHT) * (mb_width)
* BYTES_PER_PIXEL) + baseaddr;
BYTES_PER_PIXEL = BYTES_PER_PIXEL / 2; /* width 2x bigger */
BLOCK_HEIGHT = BLOCK_HEIGHT * 2; /* height 2x bigger */
for(block = lmp_all; block != NULL; block = st_getnextall(block)) {
/* calculates new block values in memry box (relative address and size) */
p = ((uintptr_t) block->ptr - baseaddr) / BYTES_PER_PIXEL;
mb_size = (block->size / BYTES_PER_PIXEL);
if (mb_size == 0) {
mb_size = 1;
}
/* check if block is inside zoom */
if (istoggled(block->luatype) && p >= 0 &&
p <= (mb_width * BYTES_PER_PIXEL) * (mb_height / BLOCK_HEIGHT)) {
drawmemblock(p, block->luatype, mb_size);
}
}
}
/* redraw blocks using smaller size and old baseaddress. */
static void zoomout() {
zoom = LMP_ZOOM_OUT; /* change zoom state */
drawstates(); /* update display with new state */
clearmembox(); /* clear memory box for new blocks without zoom mode */
BYTES_PER_PIXEL = BYTES_PER_PIXEL * 2; /* width 2x smaller */
BLOCK_HEIGHT = BLOCK_HEIGHT / 2; /* height 2x smaller */
baseaddr = laddress; /* restore baseaddress */
drawblocklist(lmp_all, st_getnextall); /* draw all blocks */
}
static void checkevent() {
int eventtype;
LMP_Event event;
if (state == LMP_EXEC) { /* normal execution - only accepts pause command */
eventtype = gr_getevent(screen, &event); /* gets an event if exists */
if (eventtype == LMP_EVENT_KEY && event.kevent.key == ' ') { /* pause */
state = LMP_PAUSE;
drawstates(); /* update display with new state */
drawreport("Press: 'space' to resume execution; 'n' to resume until next memory operation;", LMP_FLINE);
drawreport("'c' to clear the memory box; 's,f,u,h,t,o' to redraw blocks of specific type;", LMP_FLINE + 1);
drawreport("'a' to redraw all blocks; left-click for zoom in and right-click for zoom out.", LMP_FLINE + 2);
}
}
while (state != LMP_EXEC) { /* execution is paused or finished */
lmp_Block* (*fnextblock) (lmp_Block*) = st_getnexttype;
lmp_Block *block = NULL;
eventtype = gr_waitevent(screen, &event); /* wait for a valid event */
if (eventtype == LMP_EVENT_KEY) {
switch (event.kevent.key) {
case ' ': /* space key - continue - resumes normal execution */
state = LMP_EXEC;
drawstates();
drawreport("Press 'space' to Pause execution.", LMP_FLINE);
return;
case 'n': /* next - execute next memory operation */
return;
case 's': /* draw filter type - set correct list and toggle */
inverttoggle(&mi_string);
block = lmp_string;
break;
case 'f':
inverttoggle(&mi_function);
block = lmp_function;
break;
case 'u':
inverttoggle(&mi_userdata);
block = lmp_userdata;
break;
case 'h':
inverttoggle(&mi_thread);
block = lmp_thread;
break;
case 't':
inverttoggle(&mi_table);
block = lmp_table;
break;
case 'o':
inverttoggle(&mi_other);
block = lmp_other;
break;
case 'a': /* draw all blocks */
toggleall();
block = lmp_all;
fnextblock = st_getnextall;
break;
case 'c': /* erase all blocks from memory box */
untoggleall();
clearmembox();
}
drawblocklist(block, fnextblock);
} else if (eventtype == LMP_EVENT_MOUSE) {
if (event.mevent.b == LEFT_BUTTON && zoom == LMP_ZOOM_OUT) {
zoomin(event.mevent.x, event.mevent.y);
} else if (event.mevent.b == RIGHT_BUTTON && zoom == LMP_ZOOM_IN) {
zoomout();
}
}
}
}
/*
** write in bottom row the memory operation and the block info.
** block info = allocation type, block (address, type and size) and call stack
*/
static void writeblockinfo(void *ptr, size_t luatype, size_t size, int alloctype) {
char textbuff[60];
char ltype[9];
char atype[8];
switch(luatype) {
case LUA_TSTRING:
strcpy(ltype, "String");
break;
case LUA_TFUNCTION:
strcpy(ltype, "Function");
break;
case LUA_TUSERDATA:
strcpy(ltype, "Userdata");
break;
case LUA_TTHREAD:
strcpy(ltype, "Thread");
break;
case LUA_TTABLE:
strcpy(ltype, "Table");
break;
default:
strcpy(ltype, "Other");
break;
}
switch(alloctype) {
case LMP_VM_FREE:
strcpy(atype, "Free");
break;
case LMP_VM_MALLOC:
strcpy(atype, "Malloc");
break;
case LMP_VM_REALLOC:
strcpy(atype, "Realloc");
break;
}
sprintf(textbuff, "%s | addr = %p | type = %s | size = %luB", atype,
ptr, ltype, (unsigned long) size);
drawreport(textbuff, LMP_FLINE);
drawcallstack(LMP_FLINE + 1);
}
/* draw border lines and clear memory box */
static void drawmembox() {
int i;
gr_setdrawcolor(screen, BLACK);
for (i = 1; i <= BOX_BORDER; i++) {
int x1 = BOX_XINI - i, x2 = BOX_XEND + i;
int y1 = BOX_YINI - i, y2 = BOX_YEND + i;
gr_drawline(screen, x1, y1, x2, y1);
gr_drawline(screen, x1, y2, x2, y2);
gr_drawline(screen, x1, y1, x1, y2);
gr_drawline(screen, x2, y1, x2, y2);
}
clearmembox();
}
/* draw one item of the right column */
static void drawmenuitem(LMP_Menuitem *item) {
int offset = gr_gettextwidth(screen) * strlen(item->name) + 3;
int bx = item->x + offset;
int by = item->y + 4;
gr_settextcolor(screen, BLACK);
gr_drawtext(screen, item->name, item->x, item->y);
if (item->toggle) {
gr_setdrawcolor(screen, item->color);
gr_drawblock(screen, bx, bx + 10, by, 10);
} else {
gr_setdrawcolor(screen, LMP_VM_BACKGROUND_CL);
gr_drawblock(screen, bx, bx + 10, by, 10);
gr_setdrawcolor(screen, item->color);
gr_drawline(screen, bx, by, bx + 10, by);
gr_drawline(screen, bx, by, bx, by + 10);
gr_drawline(screen, bx, by+ 10, bx + 10, by + 10);
gr_drawline(screen, bx + 10, by, bx + 10, by + 10);
}
}
/* write a line division(black) and a label(red) in (x,y) coordinate */
static int drawl(const char *text, int x, int y) {
int text_width = strlen(text) * gr_gettextwidth(screen);
int center_offset = (RTCOLUMN_WIDTH - (text_width + BASE_SPACE))/2;
gr_setdrawcolor(screen, BLACK);
gr_drawline(screen, x, y, sc_width - BASE_SPACE, y);
y = y + 10;
gr_settextcolor(screen, RED);
gr_drawtext(screen, text, x + center_offset, y);
return y;
}
/* write initial message in the bottom row */
static void drawbtrow() {
gr_settextcolor(screen, BLACK);
drawreport("Welcome to the luamemprofiler library. Press 'space' to run the program", LMP_FLINE);
drawreport("normally or 'n' to execute the program until next memory operation.", LMP_FLINE + 1);
}
/* draw right column, including initial states (paused, zoom in) */
static void drawrtcolumn(float memused) {
int x = BOX_XEND + BOX_BORDER + BASE_SPACE;
int y = BOX_YINI;
int offset = 30;
char textbuff[15];
/* draw basic information */
y = drawl("BASIC INFO", x, y);
y = y + offset;
gr_settextcolor(screen, BLACK);
gr_drawtext(screen, "Memory Size", x, y);
y = y + gr_gettextwidth(screen) + 5;
sprintf(textbuff, "%.1fMb", memused);
gr_drawtext(screen, textbuff, x, y);
y = y + offset;
gr_drawtext(screen, "Granularity", x, y);
y = y + gr_gettextwidth(screen) + 5;
sprintf(textbuff, "1x2 px = %dB", BYTES_PER_PIXEL);
gr_drawtext(screen, textbuff, x, y);
y = y + offset;
/* draw key menu and labels */
y = drawl("COMMANDS", x, y);
y = y + offset;
gr_settextcolor(screen, BLACK);
initmenuitem(&mi_string, x, y, LMP_ON, LMP_VM_STRING_CL, "s - String");
drawmenuitem(&mi_string);
y = y + offset;
initmenuitem(&mi_function, x, y, LMP_ON, LMP_VM_FUNCTION_CL, "f - Function");
drawmenuitem(&mi_function);
y = y + offset;
initmenuitem(&mi_userdata, x, y, LMP_ON, LMP_VM_USERDATA_CL, "u - Userdata");
drawmenuitem(&mi_userdata);
y = y + offset;
initmenuitem(&mi_thread, x, y, LMP_ON, LMP_VM_THREAD_CL, "h - Thread");
drawmenuitem(&mi_thread);
y = y + offset;
initmenuitem(&mi_table, x, y, LMP_ON, LMP_VM_TABLE_CL, "t - Table");
drawmenuitem(&mi_table);
y = y + offset;
initmenuitem(&mi_other, x, y, LMP_ON, LMP_VM_OTHER_CL, "o - Other");
drawmenuitem(&mi_other);
y = y + offset;
gr_drawtext(screen, "a - All", x, y);
y = y + offset;
gr_drawtext(screen, "c - Clear", x, y);
y = y + offset;
gr_drawtext(screen, "n - Next", x, y);
y = y + offset;
/* draw luamemprofiler state and zoom state */
y = drawl("STATE", x, y);
y = y + offset;
statesy = y; /* set where to redraw states */
gr_settextcolor(screen, BLACK);
gr_drawtext(screen, "lmp: PAUSED", x, y);
y = y + offset;
gr_drawtext(screen, "zoom: OUT", x, y);
}
/* update states (pause x execution || [zoom] in x out */
static void drawstates() {
int x = BOX_XEND + BOX_BORDER + BASE_SPACE;
int y = statesy;
int offset = 30;
/* erase old text */
gr_setdrawcolor(screen, LMP_VM_BACKGROUND_CL);
gr_drawblock(screen, x, x + RTCOLUMN_WIDTH, y, 50);
/* write new text */
gr_settextcolor(screen, BLACK);
if(state == LMP_PAUSE) {
gr_drawtext(screen, "lmp: PAUSED", x, y);
} else if (state == LMP_EXEC) {
gr_drawtext(screen, "lmp: EXECUTING", x, y);
} else if (state == LMP_FINISH) {
gr_drawtext(screen, "lmp: FINISHED", x, y);
}
y = y + offset;
if(zoom == LMP_ZOOM_OUT) {
gr_drawtext(screen, "zoom: OUT", x, y);
} else if(zoom == LMP_ZOOM_IN) {
gr_drawtext(screen, "zoom: IN", x, y);
}
}
/* calculates and sets screen and memory box width and height */
static int setcanvassize (float memused) {
if (memused <= (float) MIN_mb_SIZE) {
mb_width = MIN_mb_WIDTH;
mb_height = MIN_mb_HEIGHT;
memused = MIN_mb_SIZE;
} else { /* MAX MEM FOR 800 x 600 resolution */
int side;
if (memused > 1) {
BYTES_PER_PIXEL = ((int) memused) * 4;
}
/* (1Mb * BLOCK_HEIGHT / BYTES_PER_PIXEL / PROPORTION(4:3)) */
side = (int) sqrt(memused*1000000*BLOCK_HEIGHT/BYTES_PER_PIXEL/(4*3))+1;
mb_width = side * 4;
mb_height = side * 3;
}
sc_width = BOX_XINI + mb_width + BOX_BORDER + BASE_SPACE + RTCOLUMN_WIDTH;
sc_height = BOX_YINI + mb_height + BOX_BORDER + BASE_SPACE + BTROW_HEIGHT;
return memused;
}
/* paint all memory box with defined color (erase drawn blocks) */
static void clearmembox() {
gr_setdrawcolor(screen, LMP_VM_MEMBOX_CL);
gr_drawblock(screen, BOX_XINI, BOX_XEND, BOX_YINI, BOX_YEND - BOX_YINI);
}
static int istoggled(size_t luatype) {
switch(luatype) {
case LUA_TSTRING:
return mi_string.toggle;
case LUA_TFUNCTION:
return mi_function.toggle;
case LUA_TUSERDATA:
return mi_userdata.toggle;
case LUA_TTHREAD:
return mi_thread.toggle;
case LUA_TTABLE:
return mi_table.toggle;
default:
return mi_other.toggle;
}
}
static void toggleall() {
mi_string.toggle = LMP_ON;
drawmenuitem(&mi_string);
mi_function.toggle = LMP_ON;
drawmenuitem(&mi_function);
mi_userdata.toggle = LMP_ON;
drawmenuitem(&mi_userdata);
mi_thread.toggle = LMP_ON;
drawmenuitem(&mi_thread);
mi_table.toggle = LMP_ON;
drawmenuitem(&mi_table);
mi_other.toggle = LMP_ON;
drawmenuitem(&mi_other);
}
static void untoggleall() {
mi_string.toggle = LMP_OFF;
drawmenuitem(&mi_string);
mi_function.toggle = LMP_OFF;
drawmenuitem(&mi_function);
mi_userdata.toggle = LMP_OFF;
drawmenuitem(&mi_userdata);
mi_thread.toggle = LMP_OFF;
drawmenuitem(&mi_thread);
mi_table.toggle = LMP_OFF;
drawmenuitem(&mi_table);
mi_other.toggle = LMP_OFF;
drawmenuitem(&mi_other);
}
static void initmenuitem(LMP_Menuitem *mi, int x, int y, int toggle,
Color color, const char* name) {
mi->x = x; mi->y = y; mi->toggle = toggle;
mi->color = color; mi->name = name;
}
/* change toggle settings and redraw menu item */
static void inverttoggle(LMP_Menuitem *mi) {
mi->toggle = !mi->toggle;
drawmenuitem(mi);
}
Reference in New Issue View Git Blame Copy Permalink