static void draw_bars(void)
{
gint x,y;
GLfloat x_offset, z_offset, r_base, b_base;
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glTranslatef(0.0,-0.5,-5.0);
glRotatef(x_angle,1.0,0.0,0.0);
glRotatef(y_angle,0.0,1.0,0.0);
glRotatef(z_angle,0.0,0.0,1.0);
glBegin(GL_TRIANGLES);
for(y = 0; y < 16; y++)
{
z_offset = -1.6 + ((15 - y) * 0.2);
b_base = y * (1.0 / 15);
r_base = 1.0 - b_base;
for(x = 0; x < 16; x++)
{
x_offset = -1.6 + (x * 0.2);
draw_bar(x_offset, z_offset, heights[y][x], r_base - (x * (r_base / 15.0)), x * (1.0 / 15), b_base);
}
}
glEnd();
glPopMatrix();
glXSwapBuffers(dpy,window);
}
void draw_bars(void)
{
int x,y;
float x_offset, z_offset, r_base, b_base;
D3DXMATRIX matRotationX, matRotationY, matRotationZ, matTranslation, matWorld;
D3DXMatrixIdentity(&matWorld);
D3DXMatrixRotationZ(&matRotationZ, D3DXToRadian(z_angle));
D3DXMatrixRotationY(&matRotationY, -D3DXToRadian(y_angle));
D3DXMatrixRotationX(&matRotationX, -D3DXToRadian(x_angle));
D3DXMatrixTranslation(&matTranslation, 0.0f, -0.5f, 5.0f);
matWorld = matRotationZ * matRotationY * matRotationX * matTranslation;
g_device->SetTransform(D3DTS_WORLD, &matWorld);
for(y = 0; y < 16; y++)
{
z_offset = -1.6f + ((15 - y) * 0.2f);
b_base = y * (1.0f / 15);
r_base = 1.0f - b_base;
for(x = 0; x < 16; x++)
{
x_offset = -1.6f + (x * 0.2f);
if (::fabs(cHeights[y][x]-heights[y][x])>hSpeed)
{
if (cHeights[y][x]<heights[y][x])
cHeights[y][x] += hSpeed;
else
cHeights[y][x] -= hSpeed;
}
draw_bar(x_offset, z_offset,
cHeights[y][x], r_base - (x * (r_base / 15.0f)),
x * (1.0f / 15), b_base);
}
}
}
int main(int argc, char* argv[]) {
int ch;
ToxWindow* a;
init_term();
init_tox();
load_data();
init_windows();
while(true) {
// Update tox.
do_tox();
// Draw.
a = &windows[w_active];
prepare_window(a->window);
a->blink = false;
draw_bar();
a->onDraw(a);
// Handle input.
ch = getch();
if(ch == '\t') {
w_active = (w_active + 1) % w_num;
}
else if(ch == KEY_BTAB) {
w_active = (w_active + w_num - 1) % w_num;
}
else if(ch != ERR) {
a->onKey(a, ch);
}
}
return 0;
}
int png_plot(struct zint_symbol *symbol, int rotate_angle, int data_type)
{
int textdone, main_width, comp_offset, large_bar_count;
char textpart[10], addon[6];
float addon_text_posn, preset_height, large_bar_height;
int i, r, textoffset, yoffset, xoffset, latch, image_width, image_height;
char *pixelbuf;
int addon_latch = 0, smalltext = 0;
int this_row, block_width, plot_height, plot_yposn, textpos;
float row_height, row_posn;
int error_number;
int default_text_posn;
int next_yposn;
unsigned char local_text[ustrlen(symbol->text) + 1];
if(symbol->show_hrt != 0) {
to_latin1(symbol->text, local_text);
} else {
local_text[0] = '\0';
}
textdone = 0;
main_width = symbol->width;
strcpy(addon, "");
comp_offset = 0;
addon_text_posn = 0.0;
row_height = 0;
if(symbol->output_options & SMALL_TEXT) {
smalltext = 1;
}
if (symbol->height == 0) {
symbol->height = 50;
}
large_bar_count = 0;
preset_height = 0.0;
for(i = 0; i < symbol->rows; i++) {
preset_height += symbol->row_height[i];
if(symbol->row_height[i] == 0) {
large_bar_count++;
}
}
if (large_bar_count == 0) {
symbol->height = preset_height;
large_bar_height = 10;
} else {
large_bar_height = (symbol->height - preset_height) / large_bar_count;
}
while(!(module_is_set(symbol, symbol->rows - 1, comp_offset))) {
comp_offset++;
}
/* Certain symbols need whitespace otherwise characters get chopped off the sides */
if ((((symbol->symbology == BARCODE_EANX) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_EANX_CC))
|| (symbol->symbology == BARCODE_ISBNX)) {
switch(ustrlen(local_text)) {
case 13: /* EAN 13 */
case 16:
case 19:
if(symbol->whitespace_width == 0) {
symbol->whitespace_width = 10;
}
main_width = 96 + comp_offset;
break;
default:
main_width = 68 + comp_offset;
}
}
if (((symbol->symbology == BARCODE_UPCA) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_UPCA_CC)) {
if(symbol->whitespace_width == 0) {
symbol->whitespace_width = 10;
main_width = 96 + comp_offset;
}
}
if (((symbol->symbology == BARCODE_UPCE) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_UPCE_CC)) {
if(symbol->whitespace_width == 0) {
symbol->whitespace_width = 10;
main_width = 51 + comp_offset;
}
}
latch = 0;
r = 0;
/* Isolate add-on text */
if(is_extendable(symbol->symbology)) {
for(i = 0; i < ustrlen(local_text); i++) {
if (latch == 1) {
addon[r] = local_text[i];
r++;
}
if (symbol->text[i] == '+') {
latch = 1;
}
}
}
addon[r] = '\0';
if(ustrlen(local_text) != 0) {
textoffset = 9;
} else {
textoffset = 0;
}
xoffset = symbol->border_width + symbol->whitespace_width;
yoffset = symbol->border_width;
image_width = 2 * (symbol->width + xoffset + xoffset);
image_height = 2 * (symbol->height + textoffset + yoffset + yoffset);
if (!(pixelbuf = (char *) malloc(image_width * image_height))) {
printf("Insufficient memory for pixel buffer");
return ZERROR_ENCODING_PROBLEM;
} else {
for(i = 0; i < (image_width * image_height); i++) {
*(pixelbuf + i) = '0';
}
}
if(((symbol->output_options & BARCODE_BOX) != 0) || ((symbol->output_options & BARCODE_BIND) != 0)) {
default_text_posn = image_height - 17;
} else {
default_text_posn = image_height - 17 - symbol->border_width - symbol->border_width;
}
row_posn = textoffset + yoffset;
next_yposn = textoffset + yoffset;
row_height = 0;
/* Plot the body of the symbol to the pixel buffer */
for(r = 0; r < symbol->rows; r++) {
this_row = symbol->rows - r - 1; /* invert r otherwise plots upside down */
row_posn += row_height;
plot_yposn = next_yposn;
if(symbol->row_height[this_row] == 0) {
row_height = large_bar_height;
} else {
row_height = symbol->row_height[this_row];
}
next_yposn = (int)(row_posn + row_height);
plot_height = next_yposn - plot_yposn;
i = 0;
if(module_is_set(symbol, this_row, 0)) {
latch = 1;
} else {
latch = 0;
}
do {
block_width = 0;
do {
block_width++;
} while (module_is_set(symbol, this_row, i + block_width) == module_is_set(symbol, this_row, i));
if((addon_latch == 0) && (r == 0) && (i > main_width)) {
plot_height = (int)(row_height - 5.0);
plot_yposn = (int)(row_posn - 5.0);
addon_text_posn = row_posn + row_height - 8.0;
addon_latch = 1;
}
if(latch == 1) {
/* a bar */
draw_bar(pixelbuf, (i + xoffset) * 2, block_width * 2, plot_yposn * 2, plot_height * 2, image_width, image_height);
latch = 0;
} else {
/* a space */
latch = 1;
}
i += block_width;
} while (i < symbol->width);
}
xoffset += comp_offset;
if ((((symbol->symbology == BARCODE_EANX) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_EANX_CC)) || (symbol->symbology == BARCODE_ISBNX)) {
/* guard bar extensions and text formatting for EAN8 and EAN13 */
switch(ustrlen(local_text)) {
case 8: /* EAN-8 */
case 11:
case 14:
draw_bar(pixelbuf, (0 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (2 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (32 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (34 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (64 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (66 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
for(i = 0; i < 4; i++) {
textpart[i] = symbol->text[i];
}
textpart[4] = '\0';
textpos = 2 * (17 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
for(i = 0; i < 4; i++) {
textpart[i] = symbol->text[i + 4];
}
textpart[4] = '\0';
textpos = 2 * (50 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
textdone = 1;
switch(strlen(addon)) {
case 2:
textpos = 2 * (xoffset + 86);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break;
case 5:
textpos = 2 * (xoffset + 100);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break;
}
break;
case 13: /* EAN 13 */
case 16:
case 19:
draw_bar(pixelbuf, (0 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (2 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (46 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (48 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (92 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (94 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
textpart[0] = symbol->text[0];
textpart[1] = '\0';
textpos = 2 * (-7 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
for(i = 0; i < 6; i++) {
textpart[i] = symbol->text[i + 1];
}
textpart[6] = '\0';
textpos = 2 * (24 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
for(i = 0; i < 6; i++) {
textpart[i] = symbol->text[i + 7];
}
textpart[6] = '\0';
textpos = 2 * (71 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
textdone = 1;
switch(strlen(addon)) {
case 2:
textpos = 2 * (xoffset + 114);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break;
case 5:
textpos = 2 * (xoffset + 128);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break;
}
break;
}
}
if (((symbol->symbology == BARCODE_UPCA) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_UPCA_CC)) {
/* guard bar extensions and text formatting for UPCA */
latch = 1;
i = 0 + comp_offset;
do {
block_width = 0;
do {
block_width++;
} while (module_is_set(symbol, symbol->rows - 1, i + block_width) == module_is_set(symbol, symbol->rows - 1, i));
if(latch == 1) {
/* a bar */
draw_bar(pixelbuf, (i + xoffset - comp_offset) * 2, block_width * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
latch = 0;
} else {
/* a space */
latch = 1;
}
i += block_width;
} while (i < 11 + comp_offset);
draw_bar(pixelbuf, (46 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (48 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
latch = 1;
i = 85 + comp_offset;
do {
block_width = 0;
do {
block_width++;
} while (module_is_set(symbol, symbol->rows - 1, i + block_width) == module_is_set(symbol, symbol->rows - 1, i));
if(latch == 1) {
/* a bar */
draw_bar(pixelbuf, (i + xoffset - comp_offset) * 2, block_width * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
latch = 0;
} else {
/* a space */
latch = 1;
}
i += block_width;
} while (i < 96 + comp_offset);
textpart[0] = symbol->text[0];
textpart[1] = '\0';
textpos = 2 * (-5 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
for(i = 0; i < 5; i++) {
textpart[i] = symbol->text[i + 1];
}
textpart[5] = '\0';
textpos = 2 * (27 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
for(i = 0; i < 5; i++) {
textpart[i] = symbol->text[i + 6];
}
textpart[6] = '\0';
textpos = 2 * (68 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
textpart[0] = symbol->text[11];
textpart[1] = '\0';
textpos = 2 * (100 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
textdone = 1;
switch(strlen(addon)) {
case 2:
textpos = 2 * (xoffset + 116);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break;
case 5:
textpos = 2 * (xoffset + 130);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break;
}
}
if (((symbol->symbology == BARCODE_UPCE) && (symbol->rows == 1)) || (symbol->symbology == BARCODE_UPCE_CC)) {
/* guard bar extensions and text formatting for UPCE */
draw_bar(pixelbuf, (0 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (2 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (46 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (48 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
draw_bar(pixelbuf, (50 + xoffset) * 2, 1 * 2, (4 + (int)yoffset) * 2, 5 * 2, image_width, image_height);
textpart[0] = symbol->text[0];
textpart[1] = '\0';
textpos = 2 * (-5 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
for(i = 0; i < 6; i++) {
textpart[i] = symbol->text[i + 1];
}
textpart[6] = '\0';
textpos = 2 * (24 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
textpart[0] = symbol->text[7];
textpart[1] = '\0';
textpos = 2 * (55 + xoffset);
draw_string(pixelbuf, textpart, textpos, default_text_posn, smalltext, image_width, image_height);
textdone = 1;
switch(strlen(addon)) {
case 2:
textpos = 2 * (xoffset + 70);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break;
case 5:
textpos = 2 * (xoffset + 84);
draw_string(pixelbuf, addon, textpos, image_height - (addon_text_posn * 2) - 13, smalltext, image_width, image_height);
break;
}
}
xoffset -= comp_offset;
/* Put boundary bars or box around symbol */
if(((symbol->output_options & BARCODE_BOX) != 0) || ((symbol->output_options & BARCODE_BIND) != 0)) {
/* boundary bars */
draw_bar(pixelbuf, 0, (symbol->width + xoffset + xoffset) * 2, textoffset * 2, symbol->border_width * 2, image_width, image_height);
draw_bar(pixelbuf, 0, (symbol->width + xoffset + xoffset) * 2, (textoffset + symbol->height + symbol->border_width) * 2, symbol->border_width * 2, image_width, image_height);
if((symbol->output_options & BARCODE_BIND) != 0) {
if((symbol->rows > 1) && (is_stackable(symbol->symbology) == 1)) {
/* row binding */
for(r = 1; r < symbol->rows; r++) {
draw_bar(pixelbuf, xoffset * 2, symbol->width * 2, ((r * row_height) + textoffset + yoffset - 1) * 2, 2 * 2, image_width, image_height);
}
}
}
}
if((symbol->output_options & BARCODE_BOX) != 0) {
/* side bars */
draw_bar(pixelbuf, 0, symbol->border_width * 2, textoffset * 2, (symbol->height + (2 * symbol->border_width)) * 2, image_width, image_height);
draw_bar(pixelbuf, (symbol->width + xoffset + xoffset - symbol->border_width) * 2, symbol->border_width * 2, textoffset * 2, (symbol->height + (2 * symbol->border_width)) * 2, image_width, image_height);
}
/* Put the human readable text at the bottom */
if((textdone == 0) && (ustrlen(local_text) != 0)) {
textpos = (image_width / 2);
draw_string(pixelbuf, (char*)local_text, textpos, default_text_posn, smalltext, image_width, image_height);
}
error_number=png_to_file(symbol, image_height, image_width, pixelbuf, rotate_angle, data_type);
free(pixelbuf);
return error_number;
}
void Spectrum::draw_bar( int i, GLfloat pos_x1, GLfloat pos_x2 ) {
// if ( ::fabs( cbar_heights[i] - bar_heights[i] ) > 0 ) {
// // The bigger the difference between the current and previous heights, the faster
// // we want the bars to move.
// // The "10.0" is a random value I choose after some testing.
// float gravity = ::fabs( this->cbar_heights[i] - this->pbar_heights[i] ) / 10.0;
//
// if ( this->cbar_heights[i] < this->bar_heights[i] ) {
// this->cbar_heights[i] += this->spectrum_animation_speed + gravity;
// } else {
// this->cbar_heights[i] -= this->spectrum_animation_speed + gravity;
// }
// }
// this->pbar_heights[i] = this->bar_heights[i];
auto&& draw_bar = [&](GLfloat x1, GLfloat x2, GLfloat y) {
glColor3f( this->spectrum_colors[ 3*i ], this->spectrum_colors[ 3*i+1 ], this->spectrum_colors[ 3*i+2 ] );
y = -y;
glBegin(GL_TRIANGLES);
glVertex2f( x1, y ); // Top Left
glVertex2f( x2, y ); // Top Right
glVertex2f( x2, this->spectrum_position_vertical ); // Bottom Right
glEnd();
glBegin(GL_TRIANGLES);
glVertex2f( x2, this->spectrum_position_vertical ); // Bottom Right
glVertex2f( x1, this->spectrum_position_vertical ); // Bottom Left
glVertex2f( x1, y ); // Top Left
glEnd();
if ( this->spectrum_mirror_horizontal ) {
x1 = x1 - ( this->spectrum_position_horizontal * 2 );
x2 = x2 - ( this->spectrum_position_horizontal * 2 );
glBegin(GL_TRIANGLES);
glVertex2f( -x2, y ); // Top Left
glVertex2f( -x1, y ); // Top Right
glVertex2f( -x1, this->spectrum_position_vertical ); // Bottom Right
glEnd();
glBegin(GL_TRIANGLES);
glVertex2f( -x1, this->spectrum_position_vertical ); // Bottom Right
glVertex2f( -x2, this->spectrum_position_vertical ); // Bottom Left
glVertex2f( -x2, y ); // Top Left
glEnd();
}
};
GLfloat y = this->cbar_heights[i];
pos_x1 = pos_x1 + this->spectrum_position_horizontal;
pos_x2 = pos_x2 + this->spectrum_position_horizontal;
if ( this->spectrum_flip_vertical ) {
y = -this->spectrum_position_vertical - this->cbar_heights[i];
draw_bar(pos_x1, pos_x2, -y);
} else {
y = this->spectrum_position_vertical - this->cbar_heights[i];
draw_bar(pos_x1, pos_x2, y);
}
if ( this->spectrum_mirror_vertical ) {
if ( this->spectrum_flip_vertical ) {
y = this->spectrum_position_vertical - this->cbar_heights[i];
draw_bar(pos_x1, pos_x2, y);
} else {
y = -this->spectrum_position_vertical - this->cbar_heights[i];
draw_bar(pos_x1, pos_x2, -y);
}
}
//draw_bar(pos_x1, pos_x2, y);
}
static void draw_rect_tests(SkCanvas* canvas) {
draw_square(canvas, 10, 10);
draw_column(canvas, 30, 10);
draw_bar(canvas, 10, 30);
}
void
w_players_in_game2::draw_bar_or_bars(SDL_Surface* s, size_t rank_index, int center_x, int maximum_value, vector<bar_info>& outBarInfos) const {
// Draw score bar
if(draw_scores_not_carnage) {
bar_info theBarInfo;
int theScore = net_rankings[rank_index].game_ranking;
calculate_ranking_text_for_post_game(temporary, theScore);
theBarInfo.label_text = temporary; // this makes a copy
draw_bar(s, center_x, _score_color, theScore, maximum_value, theBarInfo);
// Don't draw a "0" score label
if(theScore != 0)
outBarInfos.push_back(theBarInfo);
}
else {
// Draw carnage bar(s)
if(rank_index == selected_player) {
// Draw suicides/friendly-fires
bar_info theBarInfo;
const char* theSuicidesFormat = TS_GetCString(strNET_STATS_STRINGS, strSUICIDES_STRING);
int theNumberOfSuicides = net_rankings[rank_index].kills;
sprintf(temporary, theSuicidesFormat, theNumberOfSuicides);
theBarInfo.label_text = temporary; // this makes a copy
draw_bar(s, center_x, _suicide_color, theNumberOfSuicides, maximum_value, theBarInfo);
// Don't push a "0" label.
if(theNumberOfSuicides > 0)
outBarInfos.push_back(theBarInfo);
}
else {
// Draw kills and deaths
int theNumKills = net_rankings[rank_index].kills;
int theNumDeaths = net_rankings[rank_index].deaths;
// Get strings for labelling
const char* theKillsFormat;
const char* theDeathsFormat;
char theKillsString[32];
char theDeathsString[32];
// If more than threshhold bar-pairs to draw, use short form with legend rather than normal (long) form.
theKillsFormat = num_valid_net_rankings >= kUseLegendThreshhold ? "%d" : TS_GetCString(strNET_STATS_STRINGS, strKILLS_STRING);
theDeathsFormat = num_valid_net_rankings >= kUseLegendThreshhold ? "%d" : TS_GetCString(strNET_STATS_STRINGS, strDEATHS_STRING);
// Construct labels
sprintf(theKillsString, theKillsFormat, theNumKills);
sprintf(theDeathsString, theDeathsFormat, theNumDeaths);
// Set up bar_infos
bar_info theKillsBarInfo;
bar_info theDeathsBarInfo;
// Copy strings into bar_infos
theKillsBarInfo.label_text = theKillsString;
theDeathsBarInfo.label_text = theDeathsString;
// Draw shorter bar in front - looks nicer
// If equal, draw kills in front
// Put shorter bar_info in vector first so its label doesn't "leapfrog" the taller bar label in case of conflict.
// Don't put "0"s into the vector.
if(theNumKills > theNumDeaths) {
// Deaths bar is shorter - draw it last
draw_bar(s, center_x - kBarWidth / 3, _kill_color, theNumKills, maximum_value, theKillsBarInfo);
draw_bar(s, center_x + kBarWidth / 3, _death_color, theNumDeaths, maximum_value, theDeathsBarInfo);
if(theNumDeaths > 0)
outBarInfos.push_back(theDeathsBarInfo);
if(theNumKills > 0)
outBarInfos.push_back(theKillsBarInfo);
}
else {
// Kills bar is shorter or equal - draw it last
draw_bar(s, center_x + kBarWidth / 3, _death_color, theNumDeaths, maximum_value, theDeathsBarInfo);
draw_bar(s, center_x - kBarWidth / 3, _kill_color, theNumKills, maximum_value, theKillsBarInfo);
if(theNumKills > 0)
outBarInfos.push_back(theKillsBarInfo);
if(theNumDeaths > 0)
outBarInfos.push_back(theDeathsBarInfo);
} // kills and deaths (not suicides)
} // carnage bars
} // !draw_scores_not_carnage (i.e. draw carnage)
} // draw_bar_or_bars
void unit_drawer::redraw_unit (const unit & u) const
{
unit_animation_component & ac = u.anim_comp();
map_location loc = u.get_location();
int side = u.side();
bool hidden = u.get_hidden();
bool is_flying = u.is_flying();
map_location::DIRECTION facing = u.facing();
int hitpoints = u.hitpoints();
int max_hitpoints = u.max_hitpoints();
int movement_left = u.movement_left();
int total_movement = u.total_movement();
bool can_recruit = u.can_recruit();
bool can_advance = u.can_advance();
int experience = u.experience();
int max_experience = u.max_experience();
bool emit_zoc = u.emits_zoc();
SDL_Color hp_color=u.hp_color();
SDL_Color xp_color=u.xp_color();
std::string ellipse=u.image_ellipse();
if ( hidden || is_blindfolded || !u.is_visible_to_team(viewing_team_ref,map, show_everything) )
{
ac.clear_haloes();
if(ac.anim_) {
ac.anim_->update_last_draw_time();
}
return;
}
if (!ac.anim_) {
ac.set_standing();
if (!ac.anim_) return;
}
if (ac.refreshing_) return;
ac.refreshing_ = true;
ac.anim_->update_last_draw_time();
frame_parameters params;
const t_translation::t_terrain terrain = map.get_terrain(loc);
const terrain_type& terrain_info = map.get_terrain_info(terrain);
// do not set to 0 so we can distinguish the flying from the "not on submerge terrain"
// instead use -1.0 (as in "negative depth", it will be ignored by rendering)
params.submerge= is_flying ? -1.0 : terrain_info.unit_submerge();
if (u.invisible(loc) &&
params.highlight_ratio > 0.5) {
params.highlight_ratio = 0.5;
}
if (loc == sel_hex && params.highlight_ratio == 1.0) {
params.highlight_ratio = 1.5;
}
int height_adjust = static_cast<int>(terrain_info.unit_height_adjust() * zoom_factor);
if (is_flying && height_adjust < 0) {
height_adjust = 0;
}
params.y -= height_adjust;
params.halo_y -= height_adjust;
int red = 0,green = 0,blue = 0,tints = 0;
double blend_ratio = 0;
// Add future colored states here
if(u.poisoned()) {
green += 255;
blend_ratio += 0.25;
tints += 1;
}
if(u.slowed()) {
red += 191;
green += 191;
blue += 255;
blend_ratio += 0.25;
tints += 1;
}
if(tints > 0) {
params.blend_with = disp.rgb((red/tints),(green/tints),(blue/tints));
params.blend_ratio = ((blend_ratio/tints));
}
//hackish : see unit_frame::merge_parameters
// we use image_mod on the primary image
// and halo_mod on secondary images and all haloes
params.image_mod = u.image_mods();
params.halo_mod = u.TC_image_mods();
params.image= u.default_anim_image();
if(u.incapacitated()) params.image_mod +="~GS()";
params.primary_frame = t_true;
const frame_parameters adjusted_params = ac.anim_->get_current_params(params);
const map_location dst = loc.get_direction(facing);
const int xsrc = disp.get_location_x(loc);
const int ysrc = disp.get_location_y(loc);
const int xdst = disp.get_location_x(dst);
const int ydst = disp.get_location_y(dst);
const int x = static_cast<int>(adjusted_params.offset * xdst + (1.0-adjusted_params.offset) * xsrc) + hex_size_by_2;
const int y = static_cast<int>(adjusted_params.offset * ydst + (1.0-adjusted_params.offset) * ysrc) + hex_size_by_2;
bool has_halo = ac.unit_halo_ && ac.unit_halo_->valid();
if(!has_halo && !u.image_halo().empty()) {
ac.unit_halo_ = halo_man.add(0, 0, u.image_halo()+u.TC_image_mods(), map_location(-1, -1));
}
if(has_halo && u.image_halo().empty()) {
halo_man.remove(ac.unit_halo_);
ac.unit_halo_ = halo::handle(); //halo::NO_HALO;
} else if(has_halo) {
halo_man.set_location(ac.unit_halo_, x, y - height_adjust);
}
// We draw bars only if wanted, visible on the map view
bool draw_bars = ac.draw_bars_ ;
if (draw_bars) {
SDL_Rect unit_rect = sdl::create_rect(xsrc, ysrc +adjusted_params.y, hex_size, hex_size);
draw_bars = sdl::rects_overlap(unit_rect, disp.map_outside_area());
}
#ifdef SDL_GPU
sdl::timage ellipse_front;
sdl::timage ellipse_back;
#else
surface ellipse_front(nullptr);
surface ellipse_back(nullptr);
#endif
int ellipse_floating = 0;
// Always show the ellipse for selected units
if(draw_bars && (preferences::show_side_colors() || sel_hex == loc)) {
if(adjusted_params.submerge > 0.0) {
// The division by 2 seems to have no real meaning,
// It just works fine with the current center of ellipse
// and prevent a too large adjust if submerge = 1.0
ellipse_floating = static_cast<int>(adjusted_params.submerge * hex_size_by_2);
}
if(ellipse.empty()){
ellipse="misc/ellipse";
}
if(ellipse != "none") {
// check if the unit has a ZoC or can recruit
const char* const nozoc = emit_zoc ? "" : "nozoc-";
const char* const leader = can_recruit ? "leader-" : "";
const char* const selected = sel_hex == loc ? "selected-" : "";
// Load the ellipse parts recolored to match team color
char buf[100];
std::string tc=team::get_side_color_index(side);
#ifdef SDL_GPU
snprintf(buf,sizeof(buf),"%s-%s%s%stop.png~RC(ellipse_red>%s)",ellipse.c_str(),leader,nozoc,selected,tc.c_str());
ellipse_back = image::get_texture(image::locator(buf), image::SCALED_TO_ZOOM);
snprintf(buf,sizeof(buf),"%s-%s%s%sbottom.png~RC(ellipse_red>%s)",ellipse.c_str(),leader,nozoc,selected,tc.c_str());
ellipse_front = image::get_texture(image::locator(buf), image::SCALED_TO_ZOOM);
#else
snprintf(buf,sizeof(buf),"%s-%s%s%stop.png~RC(ellipse_red>%s)",ellipse.c_str(),leader,nozoc,selected,tc.c_str());
ellipse_back.assign(image::get_image(image::locator(buf), image::SCALED_TO_ZOOM));
snprintf(buf,sizeof(buf),"%s-%s%s%sbottom.png~RC(ellipse_red>%s)",ellipse.c_str(),leader,nozoc,selected,tc.c_str());
ellipse_front.assign(image::get_image(image::locator(buf), image::SCALED_TO_ZOOM));
#endif
}
}
#ifdef SDL_GPU
if (!ellipse_back.null()) {
//disp.drawing_buffer_add(display::LAYER_UNIT_BG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_back);
}
if (!ellipse_front.null()) {
//disp.drawing_buffer_add(display::LAYER_UNIT_FG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_front);
}
#else
if (ellipse_back != nullptr) {
//disp.drawing_buffer_add(display::LAYER_UNIT_BG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_back);
}
if (ellipse_front != nullptr) {
//disp.drawing_buffer_add(display::LAYER_UNIT_FG, loc,
disp.drawing_buffer_add(display::LAYER_UNIT_FIRST, loc,
xsrc, ysrc +adjusted_params.y-ellipse_floating, ellipse_front);
}
#endif
if(draw_bars) {
const image::locator* orb_img = nullptr;
const surface unit_img = image::get_image(u.default_anim_image(), image::SCALED_TO_ZOOM);
const int xoff = (hex_size - unit_img->w)/2;
const int yoff = (hex_size - unit_img->h)/2;
/*static*/ const image::locator partmoved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::partial_color() + ")" );
/*static*/ const image::locator moved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::moved_color() + ")" );
/*static*/ const image::locator ally_orb(game_config::images::orb + "~RC(magenta>" +
preferences::allied_color() + ")" );
/*static*/ const image::locator enemy_orb(game_config::images::orb + "~RC(magenta>" +
preferences::enemy_color() + ")" );
/*static*/ const image::locator unmoved_orb(game_config::images::orb + "~RC(magenta>" +
preferences::unmoved_color() + ")" );
const std::string* energy_file = &game_config::images::energy;
if(size_t(side) != viewing_team+1) {
if(disp.team_valid() &&
viewing_team_ref.is_enemy(side)) {
if (preferences::show_enemy_orb() && !u.incapacitated())
orb_img = &enemy_orb;
else
orb_img = nullptr;
} else {
if (preferences::show_allied_orb())
orb_img = &ally_orb;
else orb_img = nullptr;
}
} else {
if (preferences::show_moved_orb())
orb_img = &moved_orb;
else orb_img = nullptr;
if(playing_team == viewing_team && !u.user_end_turn()) {
if (movement_left == total_movement) {
if (preferences::show_unmoved_orb())
orb_img = &unmoved_orb;
else orb_img = nullptr;
} else if ( dc.unit_can_move(u) ) {
if (preferences::show_partial_orb())
orb_img = &partmoved_orb;
else orb_img = nullptr;
}
}
}
if (orb_img != nullptr) {
surface orb(image::get_image(*orb_img,image::SCALED_TO_ZOOM));
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc, xsrc + xoff, ysrc + yoff + adjusted_params.y, orb);
}
double unit_energy = 0.0;
if(max_hitpoints > 0) {
unit_energy = double(hitpoints)/double(max_hitpoints);
}
const int bar_shift = static_cast<int>(-5*zoom_factor);
const int hp_bar_height = static_cast<int>(max_hitpoints * u.hp_bar_scaling());
const fixed_t bar_alpha = (loc == mouse_hex || loc == sel_hex) ? ftofxp(1.0): ftofxp(0.8);
draw_bar(*energy_file, xsrc+xoff+bar_shift, ysrc+yoff+adjusted_params.y,
loc, hp_bar_height, unit_energy,hp_color, bar_alpha);
if(experience > 0 && can_advance) {
const double filled = double(experience)/double(max_experience);
const int xp_bar_height = static_cast<int>(max_experience * u.xp_bar_scaling() / std::max<int>(u.level(),1));
draw_bar(*energy_file, xsrc+xoff, ysrc+yoff+adjusted_params.y,
loc, xp_bar_height, filled, xp_color, bar_alpha);
}
if (can_recruit) {
surface crown(image::get_image(u.leader_crown(),image::SCALED_TO_ZOOM));
if(!crown.null()) {
//if(bar_alpha != ftofxp(1.0)) {
// crown = adjust_surface_alpha(crown, bar_alpha);
//}
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, crown);
}
}
for(std::vector<std::string>::const_iterator ov = u.overlays().begin(); ov != u.overlays().end(); ++ov) {
#ifdef SDL_GPU
const sdl::timage ov_img(image::get_texture(*ov, image::SCALED_TO_ZOOM));
if(!ov_img.null()) {
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc, xsrc, ysrc +adjusted_params.y, ov_img);
}
#else
const surface ov_img(image::get_image(*ov, image::SCALED_TO_ZOOM));
if(ov_img != nullptr) {
disp.drawing_buffer_add(display::LAYER_UNIT_BAR,
loc, xsrc+xoff, ysrc+yoff+adjusted_params.y, ov_img);
}
#endif
}
}
// Smooth unit movements from terrain of different elevation.
// Do this separately from above so that the health bar doesn't go up and down.
const t_translation::t_terrain terrain_dst = map.get_terrain(dst);
const terrain_type& terrain_dst_info = map.get_terrain_info(terrain_dst);
int height_adjust_unit = static_cast<int>((terrain_info.unit_height_adjust() * (1.0 - adjusted_params.offset) +
terrain_dst_info.unit_height_adjust() * adjusted_params.offset) *
zoom_factor);
if (is_flying && height_adjust_unit < 0) {
height_adjust_unit = 0;
}
params.y -= height_adjust_unit - height_adjust;
params.halo_y -= height_adjust_unit - height_adjust;
ac.anim_->redraw(params, halo_man);
ac.refreshing_ = false;
}
void sch_door(POINT point[SPOTNUM],int star_fini_flag,int *point1)
{
int mouse_x=320,mouse_y=175,mouse_key=0;
int i,flag=0;
init_point(point);
draw_bar(492,55,637,345,LIGHTGRAY);
initmouse(492,637,55,159);
cursor(mouse_x,mouse_y);
while(1)
{
newmouse(&mouse_x,&mouse_y,&mouse_key);
if(mouse_x>495&&mouse_x<635&&mouse_y>60&&mouse_y<78&&flag==1)
{
cursor(mouse_x,mouse_y);
dis_hz(495,60,point[15].name,0,20,LIGHTRED);
remark(point[15].remarks);
flag=0;
cursor(mouse_x,mouse_y);
}
if(mouse_x>495&&mouse_x<635&&mouse_y>80&&mouse_y<98&&flag==1)
{
cursor(mouse_x,mouse_y);
remark(point[16].remarks);
dis_hz(495,80,point[16].name,0,20,LIGHTRED);
flag=0;
cursor(mouse_x,mouse_y);
}
if(mouse_x>495&&mouse_x<635&&mouse_y>100&&mouse_y<118&&flag==1)
{
cursor(mouse_x,mouse_y);
dis_hz(495,100,point[17].name,0,20,LIGHTRED);
remark(point[17].remarks);
flag=0;
cursor(mouse_x,mouse_y);
}
if(mouse_x>495&&mouse_x<635&&mouse_y>120&&mouse_y<138&&flag==1)
{
cursor(mouse_x,mouse_y);
dis_hz(495,120,point[18].name,0,20,LIGHTRED);
remark(point[18].remarks);
flag=0;
cursor(mouse_x,mouse_y);
}
if(mouse_x>495&&mouse_x<635&&mouse_y>140&&mouse_y<158&&flag==1)
{
cursor(mouse_x,mouse_y);
dis_hz(495,140,point[19].name,0,20,LIGHTRED);
remark(point[19].remarks);
flag=0;
cursor(mouse_x,mouse_y);
}
if(!(mouse_x>495&&mouse_x<635&&mouse_y>60&&mouse_y<78)&&!(mouse_x>495&&mouse_x<635&&mouse_y>80&&mouse_y<98)&&
!(mouse_x>495&&mouse_x<635&&mouse_y>100&&mouse_y<118)&&!(mouse_x>495&&mouse_x<635&&mouse_y>120&&mouse_y<138)&&
!(mouse_x>495&&mouse_x<635&&mouse_y>140&&mouse_y<158)&&!(mouse_x>=495&&mouse_x<=635&&mouse_y>=160&&mouse_y<=240))
{
flag=1;
for(i=0;i<5;i++)
dis_hz(495,60+20*i,point[i+15].name,0,20,WHITE);
draw_bar1(495,160,634,240,LIGHTGRAY);
}
if(mouse_x>495&&mouse_x<635&&mouse_y>60&&mouse_y<78&&mouse_key==1)
{
cursor(mouse_x,mouse_y);
cursor(mouse_x,mouse_y);
cursor(mouse_x,mouse_y);
*point1=15;
remark(point[15].remarks);
show_sta_fin(point[15].name,star_fini_flag);
break;
}
if(mouse_x>495&&mouse_x<635&&mouse_y>80&&mouse_y<98&&mouse_key==1)
{
cursor(mouse_x,mouse_y);
cursor(mouse_x,mouse_y);
cursor(mouse_x,mouse_y);
*point1=16;
remark(point[16].remarks);
show_sta_fin(point[16].name,star_fini_flag);
break;
}
if(mouse_x>495&&mouse_x<635&&mouse_y>100&&mouse_y<118&&mouse_key==1)
{
cursor(mouse_x,mouse_y);
cursor(mouse_x,mouse_y);
cursor(mouse_x,mouse_y);
*point1=17;
remark(point[17].remarks);
show_sta_fin(point[17].name,star_fini_flag);
break;
}
if(mouse_x>495&&mouse_x<635&&mouse_y>120&&mouse_y<138&&mouse_key==1)
{
cursor(mouse_x,mouse_y);
cursor(mouse_x,mouse_y);
cursor(mouse_x,mouse_y);
*point1=18;
remark(point[18].remarks);
show_sta_fin(point[18].name,star_fini_flag);
break;
}
if(mouse_x>495&&mouse_x<635&&mouse_y>140&&mouse_y<158&&mouse_key==1)
{
cursor(mouse_x,mouse_y);
cursor(mouse_x,mouse_y);
cursor(mouse_x,mouse_y);
*point1=19;
remark(point[19].remarks);
show_sta_fin(point[19].name,star_fini_flag);
break;
}
}
}
void visualize(short *tx, short *rx, int cnt)
{
int x;
float txavg = 0;
float rxavg = 0;
static int txmax = 0;
static int rxmax = 0;
static int sametxmax = 0;
static int samerxmax = 0;
static int txbest = 0;
static int rxbest = 0;
float ms;
static struct timeval last;
struct timeval tv;
gettimeofday(&tv, NULL);
ms = (tv.tv_sec - last.tv_sec) * 1000.0 + (tv.tv_usec - last.tv_usec) / 1000.0;
for (x=0;x<cnt;x++) {
txavg += abs(tx[x]);
rxavg += abs(rx[x]);
}
txavg = abs(txavg / cnt);
rxavg = abs(rxavg / cnt);
if (txavg > txbest)
txbest = txavg;
if (rxavg > rxbest)
rxbest = rxavg;
/* Update no more than 10 times a second */
if (ms < 100)
return;
/* Save as max levels, if greater */
if (txbest > txmax) {
txmax = txbest;
sametxmax = 0;
}
if (rxbest > rxmax) {
rxmax = rxbest;
samerxmax = 0;
}
memcpy(&last, &tv, sizeof(last));
/* Clear screen */
printf("\r ");
draw_bar(rxbest, rxmax);
printf(" ");
draw_bar(txbest, txmax);
if (verbose)
printf(" Rx: %5d (%5d) Tx: %5d (%5d)", rxbest, rxmax, txbest, txmax);
txbest = 0;
rxbest = 0;
/* If we have had the same max hits for x times, clear the values */
sametxmax++;
samerxmax++;
if (sametxmax > 6) {
txmax = 0;
sametxmax = 0;
}
if (samerxmax > 6) {
rxmax = 0;
samerxmax = 0;
}
}
static void
draw_status(struct nh_player_info *pi, nh_bool threeline)
{
char buf[ui_flags.mapwidth];
int i, j, k;
if (!statuswin)
return;
if (ui_flags.statusheight < 2) {
werase(statuswin);
return;
}
/* penultimate line */
wmove(statuswin, (threeline ? 1 : 0), 0);
draw_bar(15, pi->hp, pi->hpmax, TRUE);
wprintw(statuswin, " Def:%d %s:%d", 10 - pi->ac,
pi->monnum == pi->cur_monnum ? "Xp" : "HD", pi->level);
if (threeline && pi->monnum == pi->cur_monnum) {
/* keep this synced with newuexp in exper.c */
long newuexp = 10L * (1L << pi->level);
if (pi->level >= 10)
newuexp = 10000L * (1L << (pi->level - 10));
if (pi->level >= 20)
newuexp = 10000000L * ((long)(pi->level - 19));
wprintw(statuswin, "(%ld)", newuexp - pi->xp);
}
wprintw(statuswin, " %s", pi->level_desc);
wclrtoeol(statuswin);
/* last line */
wmove(statuswin, (threeline ? 2 : 1), 0);
draw_bar(15, pi->en, pi->enmax, FALSE);
wprintw(statuswin, " %c%ld S:%ld T:%ld", pi->coinsym, pi->gold, pi->score,
pi->moves);
if (getcurx(statuswin) > 0)
wclrtoeol(statuswin);
/* status */
int mainframe_color = CLR_GRAY;
j = getmaxx(statuswin) + 1;
for (i = 0; i < pi->nr_items; i++) {
int color = CLR_WHITE, colorattr;
j -= strlen(pi->statusitems[i]) + 1;
for (k = 0; statuscolors[k].name; k++) {
if (!strcmp(pi->statusitems[i], statuscolors[k].name)) {
color = statuscolors[k].color;
if (statuscolors[k].framecolor != -1)
mainframe_color = statuscolors[k].framecolor;
break;
}
}
colorattr = curses_color_attr(color, 0);
wmove(statuswin, (threeline ? 2 : 1), j);
wattron(statuswin, colorattr);
wprintw(statuswin, "%s", pi->statusitems[i]);
wattroff(statuswin, colorattr);
}
/* frame color */
if (pi->hp * 7 <= pi->hpmax)
mainframe_color = CLR_ORANGE;
else if (pi->hp * 3 <= pi->hpmax)
mainframe_color = CLR_RED;
if (ui_flags.current_followmode != FM_PLAY)
mainframe_color = CLR_BLACK; /* a hint that we can't write */
/* We change the frame color via palette manipulation, because it's awkward
to correctly redraw otherwise. However, we don't want to do color
mapping logic here. So we copy an existing palette entry. */
uncursed_color fgcode, bgcode;
pair_content(PAIR_NUMBER(curses_color_attr(mainframe_color, 0)),
&fgcode, &bgcode);
init_pair(MAINFRAME_PAIR, fgcode, bgcode);
/* name */
if (threeline) {
sprintf(buf, "%.12s the %s %s", pi->plname,
(pi->align == A_CHAOTIC) ? "Chaotic" :
(pi->align == A_NEUTRAL) ? "Neutral" :
"Lawful", pi->rank);
wmove(statuswin, 0, 0);
} else {
sprintf(buf, "%.12s, %s", pi->plname, pi->rank);
wmove(statuswin, 0, getmaxx(statuswin) - strlen(buf));
}
wprintw(statuswin, "%s", buf);
if (getcurx(statuswin) > 0)
wclrtoeol(statuswin);
/* abilities (in threeline mode) "In:18 Wi:18 Ch:18" = 17 chars */
if (threeline) {
wmove(statuswin, 0, getmaxx(statuswin) - (pi->st == 18 ? 20 : 17));
wprintw(statuswin, "Dx:%-2d Co:%-2d St:%-2d", pi->dx, pi->co, pi->st);
if (pi->st == 18 && pi->st_extra == 100)
wprintw(statuswin, "/**");
else if (pi->st == 18)
wprintw(statuswin, "/%02d", pi->st_extra);
wmove(statuswin, 1, getmaxx(statuswin) - (pi->st == 18 ? 20 : 17));
wprintw(statuswin, "In:%-2d Wi:%-2d Ch:%-2d", pi->in, pi->wi, pi->ch);
}
}
void expose(XEvent* event){
XExposeEvent *ev = &event->xexpose;
if(ev->count == 0) draw_bar(get_current_monitor());
}
int main(int argc, char* argv[]) {
int ch;
int i = 0;
int f_flag = 0;
char *filename = "data";
ToxWindow* a;
for(i = 0; i < argc; i++) {
if (argv[i] == NULL){
break;
} else if(argv[i][0] == '-') {
if(argv[i][1] == 'f') {
if(argv[i + 1] != NULL)
filename = argv[i + 1];
else {
f_flag = -1;
}
}
}
}
init_term();
init_tox();
load_data(filename);
init_windows();
if(f_flag == -1) {
attron(COLOR_PAIR(3) | A_BOLD);
wprintw(prompt->window, "You passed '-f' without giving an argument!\n"
"defaulting to 'data' for a keyfile...\n");
attroff(COLOR_PAIR(3) | A_BOLD);
}
while(true) {
// Update tox.
do_tox();
// Draw.
a = &windows[w_active];
prepare_window(a->window);
a->blink = false;
draw_bar();
a->onDraw(a);
// Handle input.
ch = getch();
if(ch == '\t') {
w_active = (w_active + 1) % w_num;
}
else if(ch == KEY_BTAB) {
w_active = (w_active + w_num - 1) % w_num;
}
else if(ch != ERR) {
a->onKey(a, ch);
}
}
return 0;
}