dpi.h File Reference

#include "includes.h"
#include "device.h"

Include dependency graph for dpi.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	updatedpi (usbdevice *kb, int force)
int	savedpi (usbdevice *kb, dpiset *dpi, lighting *light)
int	loaddpi (usbdevice *kb, dpiset *dpi, lighting *light)
char *	printdpi (const dpiset *dpi, const usbdevice *kb)
void	cmd_dpi (usbdevice *kb, usbmode *mode, int dummy, const char *stages, const char *values)
void	cmd_dpisel (usbdevice *kb, usbmode *mode, int dummy1, int dummy2, const char *stage)
void	cmd_lift (usbdevice *kb, usbmode *mode, int dummy1, int dummy2, const char *height)
void	cmd_snap (usbdevice *kb, usbmode *mode, int dummy1, int dummy2, const char *enable)

Function Documentation

void cmd_dpi	(	usbdevice *	kb,
		usbmode *	mode,
		int	dummy,
		const char *	stages,
		const char *	values
	)

Definition at line 4 of file dpi.c.

References usbmode::dpi, DPI_COUNT, dpiset::enabled, left, dpiset::x, x, dpiset::y, and y.

                                                                                             {
    (void)kb;
    (void)dummy;

    int disable = 0;
    ushort x, y;
    // Try to scan X,Y values
    if(sscanf(values, "%hu,%hu", &x, &y) != 2){
        // If that doesn't work, scan single number
        if(sscanf(values, "%hu", &x) == 1)
            y = x;
        else if(!strncmp(values, "off", 3))
            // If the right side says "off", disable the level(s)
            disable = 1;
        else
            // Otherwise, quit
            return;
    }
    if((x == 0 || y == 0) && !disable)
        return;
    // Scan the left side for stage numbers (comma-separated)
    int left = strlen(stages);
    int position = 0, field = 0;
    char stagename[3];
    while(position < left && sscanf(stages + position, "%2[^,]%n", stagename, &field) == 1){
        uchar stagenum;
        if(sscanf(stagename, "%hhu", &stagenum) && stagenum < DPI_COUNT){
            // Set DPI for this stage
            if(disable){
                mode->dpi.enabled &= ~(1 << stagenum);
                mode->dpi.x[stagenum] = 0;
                mode->dpi.y[stagenum] = 0;
            } else {
                mode->dpi.enabled |= 1 << stagenum;
                mode->dpi.x[stagenum] = x;
                mode->dpi.y[stagenum] = y;
            }
        }
        if(stages[position += field] == ',')
            position++;
    }
}

void cmd_dpisel	(	usbdevice *	kb,
		usbmode *	mode,
		int	dummy1,
		int	dummy2,
		const char *	stage
	)

Definition at line 47 of file dpi.c.

References dpiset::current, usbmode::dpi, and DPI_COUNT.

                                                                                        {
    (void)kb;
    (void)dummy1;
    (void)dummy2;

    uchar stagenum;
    if(sscanf(stage, "%hhu", &stagenum) != 1)
        return;
    if(stagenum > DPI_COUNT)
        return;
    mode->dpi.current = stagenum;
}

void cmd_lift	(	usbdevice *	kb,
		usbmode *	mode,
		int	dummy1,
		int	dummy2,
		const char *	height
	)

Definition at line 60 of file dpi.c.

References usbmode::dpi, dpiset::lift, LIFT_MAX, and LIFT_MIN.

                                                                                       {
    (void)kb;
    (void)dummy1;
    (void)dummy2;

    uchar heightnum;
    if(sscanf(height, "%hhu", &heightnum) != 1)
        return;
    if(heightnum > LIFT_MAX || heightnum < LIFT_MIN)
        return;
    mode->dpi.lift = heightnum;
}

void cmd_snap	(	usbdevice *	kb,
		usbmode *	mode,
		int	dummy1,
		int	dummy2,
		const char *	enable
	)

Definition at line 73 of file dpi.c.

References usbmode::dpi, and dpiset::snap.

                                                                                       {
    (void)kb;
    (void)dummy1;
    (void)dummy2;

    if(!strcmp(enable, "on"))
        mode->dpi.snap = 1;
    if(!strcmp(enable, "off"))
        mode->dpi.snap = 0;
}

int loaddpi	(	usbdevice *	kb,
		dpiset *	dpi,
		lighting *	light
	)

Definition at line 222 of file dpi.c.

References lighting::b, ckb_err, dpiset::current, DPI_COUNT, dpiset::enabled, lighting::g, LED_MOUSE, dpiset::lift, LIFT_MAX, LIFT_MIN, MSG_SIZE, N_MOUSE_ZONES, lighting::r, dpiset::snap, usbrecv, dpiset::x, and dpiset::y.

Referenced by cmd_hwload_mouse().

                                                        {
    // Ask for settings
    uchar data_pkt[4][MSG_SIZE] = {
        { 0x0e, 0x13, 0x05, 1, },
        { 0x0e, 0x13, 0x02, 1, },
        { 0x0e, 0x13, 0x03, 1, },
        { 0x0e, 0x13, 0x04, 1, }
    };
    uchar in_pkt[4][MSG_SIZE];
    for(int i = 0; i < 4; i++){
        if(!usbrecv(kb, data_pkt[i], in_pkt[i]))
            return -2;
        if(memcmp(in_pkt[i], data_pkt[i], 4)){
            ckb_err("Bad input header\n");
            return -3;
        }
    }
    // Copy data from device
    dpi->enabled = in_pkt[0][4];
    dpi->enabled &= (1 << DPI_COUNT) - 1;
    dpi->current = in_pkt[1][4];
    if(dpi->current >= DPI_COUNT)
        dpi->current = 0;
    dpi->lift = in_pkt[2][4];
    if(dpi->lift < LIFT_MIN || dpi->lift > LIFT_MAX)
        dpi->lift = LIFT_MIN;
    dpi->snap = !!in_pkt[3][4];

    // Get X/Y DPIs
    for(int i = 0; i < DPI_COUNT; i++){
        uchar data_pkt[MSG_SIZE] = { 0x0e, 0x13, 0xd0, 1 };
        uchar in_pkt[MSG_SIZE];
        data_pkt[2] |= i;
        if(!usbrecv(kb, data_pkt, in_pkt))
            return -2;
        if(memcmp(in_pkt, data_pkt, 4)){
            ckb_err("Bad input header\n");
            return -3;
        }
        // Copy to profile
        dpi->x[i] = *(ushort*)(in_pkt + 5);
        dpi->y[i] = *(ushort*)(in_pkt + 7);
        light->r[LED_MOUSE + N_MOUSE_ZONES + i] = in_pkt[9];
        light->g[LED_MOUSE + N_MOUSE_ZONES + i] = in_pkt[10];
        light->b[LED_MOUSE + N_MOUSE_ZONES + i] = in_pkt[11];
    }
    // Finished. Set SW DPI light to the current hardware level
    light->r[LED_MOUSE + 2] = light->r[LED_MOUSE + N_MOUSE_ZONES + dpi->current];
    light->g[LED_MOUSE + 2] = light->g[LED_MOUSE + N_MOUSE_ZONES + dpi->current];
    light->b[LED_MOUSE + 2] = light->b[LED_MOUSE + N_MOUSE_ZONES + dpi->current];
    return 0;
}

Here is the caller graph for this function:

char* printdpi	(	const dpiset *	dpi,
		const usbdevice *	kb
	)

Definition at line 84 of file dpi.c.

References _readlines_ctx::buffer, DPI_COUNT, dpiset::enabled, dpiset::x, and dpiset::y.

Referenced by _cmd_get().

                                                      {
    (void)kb;

    // Print all DPI settings
    const int BUFFER_LEN = 100;
    char* buffer = malloc(BUFFER_LEN);
    int length = 0;
    for(int i = 0; i < DPI_COUNT; i++){
        // Print the stage number
        int newlen = 0;
        snprintf(buffer + length, BUFFER_LEN - length, length == 0 ? "%d%n" : " %d%n", i, &newlen);
        length += newlen;
        // Print the DPI settings
        if(!(dpi->enabled & (1 << i)))
            snprintf(buffer + length, BUFFER_LEN - length, ":off%n", &newlen);
        else
            snprintf(buffer + length, BUFFER_LEN - length, ":%u,%u%n", dpi->x[i], dpi->y[i], &newlen);
        length += newlen;
    }
    return buffer;
}

Here is the caller graph for this function:

int savedpi	(	usbdevice *	kb,
		dpiset *	dpi,
		lighting *	light
	)

Definition at line 194 of file dpi.c.

References lighting::b, dpiset::current, DPI_COUNT, dpiset::enabled, lighting::g, LED_MOUSE, dpiset::lift, MSG_SIZE, N_MOUSE_ZONES, lighting::r, dpiset::snap, usbsend, dpiset::x, and dpiset::y.

Referenced by cmd_hwsave_mouse().

                                                        {
    // Send X/Y DPIs
    for(int i = 0; i < DPI_COUNT; i++){
        uchar data_pkt[MSG_SIZE] = { 0x07, 0x13, 0xd0, 1 };
        data_pkt[2] |= i;
        *(ushort*)(data_pkt + 5) = dpi->x[i];
        *(ushort*)(data_pkt + 7) = dpi->y[i];
        // Save the RGB value for this setting too
        data_pkt[9] = light->r[LED_MOUSE + N_MOUSE_ZONES + i];
        data_pkt[10] = light->g[LED_MOUSE + N_MOUSE_ZONES + i];
        data_pkt[11] = light->b[LED_MOUSE + N_MOUSE_ZONES + i];
        if(!usbsend(kb, data_pkt, 1))
            return -1;
    }

    // Send settings
    uchar data_pkt[4][MSG_SIZE] = {
        { 0x07, 0x13, 0x05, 1, dpi->enabled },
        { 0x07, 0x13, 0x02, 1, dpi->current },
        { 0x07, 0x13, 0x03, 1, dpi->lift },
        { 0x07, 0x13, 0x04, 1, dpi->snap, 0x05 }
    };
    if(!usbsend(kb, data_pkt[0], 4))
        return -2;
    // Finished
    return 0;
}

Here is the caller graph for this function:

int updatedpi	(	usbdevice *	kb,
		int	force
	)

Definition at line 106 of file dpi.c.

References usbdevice::active, dpiset::current, usbprofile::currentmode, usbmode::dpi, DPI_COUNT, dpiset::enabled, dpiset::forceupdate, usbprofile::lastdpi, dpiset::lift, MSG_SIZE, usbdevice::profile, dpiset::snap, usbsend, dpiset::x, and dpiset::y.

                                       {
    if(!kb->active)
        return 0;
    dpiset* lastdpi = &kb->profile->lastdpi;
    dpiset* newdpi = &kb->profile->currentmode->dpi;
    // Don't do anything if the settings haven't changed
    if(!force && !lastdpi->forceupdate && !newdpi->forceupdate
            && !memcmp(lastdpi, newdpi, sizeof(dpiset)))
        return 0;
    lastdpi->forceupdate = newdpi->forceupdate = 0;

    if (newdpi->current != lastdpi->current) {
        // Before we switch the current DPI stage, make sure the stage we are
        // switching to is both enabled and configured to the correct DPI.

        // Enable the stage if necessary.
        if ((lastdpi->enabled & 1 << newdpi->current) == 0) {
            uchar newenabled;
            // If the new enabled flags contain both the current and previous
            // stages, use it.
            if (newdpi->enabled & 1 << newdpi->current &&
                newdpi->enabled & 1 << lastdpi->current) {
                newenabled = newdpi->enabled;
            } else {
                // Otherwise just enable the new stage. We'll write the actual
                // requested flags after switching stages.
                newenabled = lastdpi->enabled | 1 << newdpi->current;
            }
            uchar data_pkt[MSG_SIZE] = { 0x07, 0x13, 0x05, 0, newenabled };
            if(!usbsend(kb, data_pkt, 1))
                return -2;
            // Cache the flags we wrote.
            lastdpi->enabled = newenabled;
        }
        // Set the DPI for the new stage if necessary.
        if (newdpi->x[newdpi->current] != lastdpi->x[newdpi->current] ||
            newdpi->y[newdpi->current] != lastdpi->y[newdpi->current]) {
            uchar data_pkt[MSG_SIZE] = { 0x07, 0x13, 0xd0, 0 };
            data_pkt[2] |= newdpi->current;
            *(ushort*)(data_pkt + 5) = newdpi->x[newdpi->current];
            *(ushort*)(data_pkt + 7) = newdpi->y[newdpi->current];
            if(!usbsend(kb, data_pkt, 1))
                return -1;
            // Set these values in the cache so we don't rewrite them.
            lastdpi->x[newdpi->current] = newdpi->x[newdpi->current];
            lastdpi->y[newdpi->current] = newdpi->y[newdpi->current];
        }
        // Set current DPI stage.
        uchar data_pkt[MSG_SIZE] = { 0x07, 0x13, 0x02, 0, newdpi->current };
        if(!usbsend(kb, data_pkt, 1))
            return -2;
    }
    
    // Send X/Y DPIs. We've changed to the new stage already so these can be set
    // safely.
    for(int i = 0; i < DPI_COUNT; i++){
        if (newdpi->x[i] == lastdpi->x[i] && newdpi->y[i] == lastdpi->y[i])
            continue;
        uchar data_pkt[MSG_SIZE] = { 0x07, 0x13, 0xd0, 0 };
        data_pkt[2] |= i;
        *(ushort*)(data_pkt + 5) = newdpi->x[i];
        *(ushort*)(data_pkt + 7) = newdpi->y[i];
        if(!usbsend(kb, data_pkt, 1))
            return -1;
    }

    // Send settings
    if (newdpi->enabled != lastdpi->enabled) {
        uchar data_pkt[MSG_SIZE] = { 0x07, 0x13, 0x05, 0, newdpi->enabled };
        if(!usbsend(kb, data_pkt, 1))
            return -2;
    }
    if (newdpi->lift != lastdpi->lift) {
        uchar data_pkt[MSG_SIZE] = { 0x07, 0x13, 0x03, 0, newdpi->lift };
        if(!usbsend(kb, data_pkt, 1))
            return -2;
    }
    if (newdpi->snap != lastdpi->snap) {
        uchar data_pkt[MSG_SIZE] = { 0x07, 0x13, 0x04, 0, newdpi->snap, 0x05 };
        if(!usbsend(kb, data_pkt, 1))
            return -2;
    }

    // Finished
    memcpy(lastdpi, newdpi, sizeof(dpiset));
    return 0;
}