Annotation of brogue-ce/src/brogue/Buttons.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: * Buttons.c
! 3: * Brogue
! 4: *
! 5: * Created by Brian Walker on 11/18/11.
! 6: * Copyright 2012. All rights reserved.
! 7: *
! 8: * This file is part of Brogue.
! 9: *
! 10: * This program is free software: you can redistribute it and/or modify
! 11: * it under the terms of the GNU Affero General Public License as
! 12: * published by the Free Software Foundation, either version 3 of the
! 13: * License, or (at your option) any later version.
! 14: *
! 15: * This program is distributed in the hope that it will be useful,
! 16: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 17: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 18: * GNU Affero General Public License for more details.
! 19: *
! 20: * You should have received a copy of the GNU Affero General Public License
! 21: * along with this program. If not, see <http://www.gnu.org/licenses/>.
! 22: */
! 23:
! 24: #include "Rogue.h"
! 25: #include "IncludeGlobals.h"
! 26: #include <math.h>
! 27: #include <time.h>
! 28:
! 29: // Draws the smooth gradient that appears on a button when you hover over or depress it.
! 30: // Returns the percentage by which the current tile should be averaged toward a hilite color.
! 31: short smoothHiliteGradient(const short currentXValue, const short maxXValue) {
! 32: return (short) (100 * sin(3.14159265 * currentXValue / maxXValue));
! 33: }
! 34:
! 35: // Draws the button to the screen, or to a display buffer if one is given.
! 36: // Button back color fades from -50% intensity at the edges to the back color in the middle.
! 37: // Text is white, but can use color escapes.
! 38: // Hovering highlight augments fore and back colors with buttonHoverColor by 20%.
! 39: // Pressed darkens the middle color (or turns it the hover color if the button is black).
! 40: void drawButton(brogueButton *button, enum buttonDrawStates highlight, cellDisplayBuffer dbuf[COLS][ROWS]) {
! 41: short i, textLoc, width, midPercent, symbolNumber, opacity, oldRNG;
! 42: color fColor, bColor, fColorBase, bColorBase, bColorEdge, bColorMid;
! 43: enum displayGlyph displayCharacter;
! 44:
! 45: if (!(button->flags & B_DRAW)) {
! 46: return;
! 47: }
! 48: //assureCosmeticRNG;
! 49: oldRNG = rogue.RNG;
! 50: rogue.RNG = RNG_COSMETIC;
! 51:
! 52: symbolNumber = 0;
! 53:
! 54: width = strLenWithoutEscapes(button->text);
! 55: bColorBase = button->buttonColor;
! 56: fColorBase = ((button->flags & B_ENABLED) ? white : gray);
! 57:
! 58: if (highlight == BUTTON_HOVER && (button->flags & B_HOVER_ENABLED)) {
! 59: //applyColorAugment(&fColorBase, &buttonHoverColor, 20);
! 60: //applyColorAugment(&bColorBase, &buttonHoverColor, 20);
! 61: applyColorAverage(&fColorBase, &buttonHoverColor, 25);
! 62: applyColorAverage(&bColorBase, &buttonHoverColor, 25);
! 63: }
! 64:
! 65: bColorEdge = bColorBase;
! 66: bColorMid = bColorBase;
! 67: applyColorAverage(&bColorEdge, &black, 50);
! 68:
! 69: if (highlight == BUTTON_PRESSED) {
! 70: applyColorAverage(&bColorMid, &black, 75);
! 71: if (COLOR_DIFF(bColorMid, bColorBase) < 50) {
! 72: bColorMid = bColorBase;
! 73: applyColorAverage(&bColorMid, &buttonHoverColor, 50);
! 74: }
! 75: }
! 76: bColor = bColorMid;
! 77:
! 78: opacity = button->opacity;
! 79: if (highlight == BUTTON_HOVER || highlight == BUTTON_PRESSED) {
! 80: opacity = 100 - ((100 - opacity) * opacity / 100); // Apply the opacity twice.
! 81: }
! 82:
! 83: for (i = textLoc = 0; i < width && i + button->x < COLS; i++, textLoc++) {
! 84: while (button->text[textLoc] == COLOR_ESCAPE) {
! 85: textLoc = decodeMessageColor(button->text, textLoc, &fColorBase);
! 86: }
! 87:
! 88: fColor = fColorBase;
! 89:
! 90: if (button->flags & B_GRADIENT) {
! 91: midPercent = smoothHiliteGradient(i, width - 1);
! 92: bColor = bColorEdge;
! 93: applyColorAverage(&bColor, &bColorMid, midPercent);
! 94: }
! 95:
! 96: if (highlight == BUTTON_PRESSED) {
! 97: applyColorAverage(&fColor, &bColor, 30);
! 98: }
! 99:
! 100: if (button->opacity < 100) {
! 101: applyColorAverage(&fColor, &bColor, 100 - opacity);
! 102: }
! 103:
! 104: bakeColor(&fColor);
! 105: bakeColor(&bColor);
! 106: separateColors(&fColor, &bColor);
! 107:
! 108: displayCharacter = button->text[textLoc];
! 109: if (button->text[textLoc] == '*') {
! 110: if (button->symbol[symbolNumber]) {
! 111: displayCharacter = button->symbol[symbolNumber];
! 112: }
! 113: symbolNumber++;
! 114: }
! 115:
! 116: if (coordinatesAreInWindow(button->x + i, button->y)) {
! 117: if (dbuf) {
! 118: plotCharToBuffer(displayCharacter, button->x + i, button->y, &fColor, &bColor, dbuf);
! 119: dbuf[button->x + i][button->y].opacity = opacity;
! 120: } else {
! 121: plotCharWithColor(displayCharacter, button->x + i, button->y, &fColor, &bColor);
! 122: }
! 123: }
! 124: }
! 125: restoreRNG;
! 126: }
! 127:
! 128: void initializeButton(brogueButton *button) {
! 129: memset((void *) button, 0, sizeof( brogueButton ));
! 130: button->text[0] = '\0';
! 131: button->flags |= (B_ENABLED | B_GRADIENT | B_HOVER_ENABLED | B_DRAW | B_KEYPRESS_HIGHLIGHT);
! 132: button->buttonColor = interfaceButtonColor;
! 133: button->opacity = 100;
! 134: }
! 135:
! 136: void drawButtonsInState(buttonState *state) {
! 137: short i;
! 138:
! 139: // Draw the buttons to the dbuf:
! 140: for (i=0; i < state->buttonCount; i++) {
! 141: if (state->buttons[i].flags & B_DRAW) {
! 142: drawButton(&(state->buttons[i]), BUTTON_NORMAL, state->dbuf);
! 143: }
! 144: }
! 145: }
! 146:
! 147: void initializeButtonState(buttonState *state,
! 148: brogueButton *buttons,
! 149: short buttonCount,
! 150: short winX,
! 151: short winY,
! 152: short winWidth,
! 153: short winHeight) {
! 154: short i, j;
! 155:
! 156: // Initialize variables for the state struct:
! 157: state->buttonChosen = state->buttonFocused = state->buttonDepressed = -1;
! 158: state->buttonCount = buttonCount;
! 159: state->winX = winX;
! 160: state->winY = winY;
! 161: state->winWidth = winWidth;
! 162: state->winHeight = winHeight;
! 163: for (i=0; i < state->buttonCount; i++) {
! 164: state->buttons[i] = buttons[i];
! 165: }
! 166: copyDisplayBuffer(state->rbuf, displayBuffer);
! 167: clearDisplayBuffer(state->dbuf);
! 168:
! 169: drawButtonsInState(state);
! 170:
! 171: // Clear the rbuf so that it resets only those parts of the screen in which buttons are drawn in the first place:
! 172: for (i=0; i<COLS; i++) {
! 173: for (j=0; j<ROWS; j++) {
! 174: state->rbuf[i][j].opacity = (state->dbuf[i][j].opacity ? 100 : 0);
! 175: }
! 176: }
! 177: }
! 178:
! 179: // Processes one round of user input, and bakes the necessary graphical changes into state->dbuf.
! 180: // Does NOT display the buttons or revert the display afterward.
! 181: // Assumes that the display has already been updated (via overlayDisplayBuffer(state->dbuf, NULL))
! 182: // and that input has been solicited (via nextBrogueEvent(event, ___, ___, ___)).
! 183: // Also relies on the buttonState having been initialized with initializeButtonState() or otherwise.
! 184: // Returns the index of a button if one is chosen.
! 185: // Otherwise, returns -1. That can be if the user canceled (in which case *canceled is true),
! 186: // or, more commonly, if the user's input in this particular split-second round was not decisive.
! 187: short processButtonInput(buttonState *state, boolean *canceled, rogueEvent *event) {
! 188: short i, k, x, y;
! 189: boolean buttonUsed = false;
! 190:
! 191: // Mouse event:
! 192: if (event->eventType == MOUSE_DOWN
! 193: || event->eventType == MOUSE_UP
! 194: || event->eventType == MOUSE_ENTERED_CELL) {
! 195:
! 196: x = event->param1;
! 197: y = event->param2;
! 198:
! 199: // Revert the button with old focus, if any.
! 200: if (state->buttonFocused >= 0) {
! 201: drawButton(&(state->buttons[state->buttonFocused]), BUTTON_NORMAL, state->dbuf);
! 202: state->buttonFocused = -1;
! 203: }
! 204:
! 205: // Find the button with new focus, if any.
! 206: for (i=0; i < state->buttonCount; i++) {
! 207: if ((state->buttons[i].flags & B_DRAW)
! 208: && (state->buttons[i].flags & B_ENABLED)
! 209: && (state->buttons[i].y == y || ((state->buttons[i].flags & B_WIDE_CLICK_AREA) && abs(state->buttons[i].y - y) <= 1))
! 210: && x >= state->buttons[i].x
! 211: && x < state->buttons[i].x + strLenWithoutEscapes(state->buttons[i].text)) {
! 212:
! 213: state->buttonFocused = i;
! 214: if (event->eventType == MOUSE_DOWN) {
! 215: state->buttonDepressed = i; // Keeps track of which button is down at the moment. Cleared on mouseup.
! 216: }
! 217: break;
! 218: }
! 219: }
! 220: if (i == state->buttonCount) { // No focus this round.
! 221: state->buttonFocused = -1;
! 222: }
! 223:
! 224: if (state->buttonDepressed >= 0) {
! 225: if (state->buttonDepressed == state->buttonFocused) {
! 226: drawButton(&(state->buttons[state->buttonDepressed]), BUTTON_PRESSED, state->dbuf);
! 227: }
! 228: } else if (state->buttonFocused >= 0) {
! 229: // If no button is depressed, then update the appearance of the button with the new focus, if any.
! 230: drawButton(&(state->buttons[state->buttonFocused]), BUTTON_HOVER, state->dbuf);
! 231: }
! 232:
! 233: // Mouseup:
! 234: if (event->eventType == MOUSE_UP) {
! 235: if (state->buttonDepressed == state->buttonFocused && state->buttonFocused >= 0) {
! 236: // If a button is depressed, and the mouseup happened on that button, it has been chosen and we're done.
! 237: buttonUsed = true;
! 238: } else {
! 239: // Otherwise, no button is depressed. If one was previously depressed, redraw it.
! 240: if (state->buttonDepressed >= 0) {
! 241: drawButton(&(state->buttons[state->buttonDepressed]), BUTTON_NORMAL, state->dbuf);
! 242: } else if (!(x >= state->winX && x < state->winX + state->winWidth
! 243: && y >= state->winY && y < state->winY + state->winHeight)) {
! 244: // Clicking outside of a button means canceling.
! 245: if (canceled) {
! 246: *canceled = true;
! 247: }
! 248: }
! 249:
! 250: if (state->buttonFocused >= 0) {
! 251: // Buttons don't hover-highlight when one is depressed, so we have to fix that when the mouse is up.
! 252: drawButton(&(state->buttons[state->buttonFocused]), BUTTON_HOVER, state->dbuf);
! 253: }
! 254: state->buttonDepressed = -1;
! 255: }
! 256: }
! 257: }
! 258:
! 259: // Keystroke:
! 260: if (event->eventType == KEYSTROKE) {
! 261:
! 262: // Cycle through all of the hotkeys of all of the buttons.
! 263: for (i=0; i < state->buttonCount; i++) {
! 264: for (k = 0; k < 10 && state->buttons[i].hotkey[k]; k++) {
! 265: if (event->param1 == state->buttons[i].hotkey[k]) {
! 266: // This button was chosen.
! 267:
! 268: if (state->buttons[i].flags & B_DRAW) {
! 269: // Restore the depressed and focused buttons.
! 270: if (state->buttonDepressed >= 0) {
! 271: drawButton(&(state->buttons[state->buttonDepressed]), BUTTON_NORMAL, state->dbuf);
! 272: }
! 273: if (state->buttonFocused >= 0) {
! 274: drawButton(&(state->buttons[state->buttonFocused]), BUTTON_NORMAL, state->dbuf);
! 275: }
! 276:
! 277: // If the button likes to flash when keypressed:
! 278: if (state->buttons[i].flags & B_KEYPRESS_HIGHLIGHT) {
! 279: // Depress the chosen button.
! 280: drawButton(&(state->buttons[i]), BUTTON_PRESSED, state->dbuf);
! 281:
! 282: // Update the display.
! 283: overlayDisplayBuffer(state->rbuf, NULL);
! 284: overlayDisplayBuffer(state->dbuf, NULL);
! 285:
! 286: // Wait for a little; then we're done.
! 287: pauseBrogue(50);
! 288: }
! 289: }
! 290:
! 291: state->buttonDepressed = i;
! 292: buttonUsed = true;
! 293: break;
! 294: }
! 295: }
! 296: }
! 297:
! 298: if (!buttonUsed
! 299: && (event->param1 == ESCAPE_KEY || event->param1 == ACKNOWLEDGE_KEY)) {
! 300: // If the player pressed escape, we're done.
! 301: if (canceled) {
! 302: *canceled = true;
! 303: }
! 304: }
! 305: }
! 306:
! 307: if (buttonUsed) {
! 308: state->buttonChosen = state->buttonDepressed;
! 309: return state->buttonChosen;
! 310: } else {
! 311: return -1;
! 312: }
! 313: }
! 314:
! 315: // Displays a bunch of buttons and collects user input.
! 316: // Returns the index number of the chosen button, or -1 if the user cancels.
! 317: // A window region is described by winX, winY, winWidth and winHeight.
! 318: // Clicking outside of that region will constitute canceling.
! 319: short buttonInputLoop(brogueButton *buttons,
! 320: short buttonCount,
! 321: short winX,
! 322: short winY,
! 323: short winWidth,
! 324: short winHeight,
! 325: rogueEvent *returnEvent) {
! 326: short button;
! 327: boolean canceled;
! 328: rogueEvent theEvent;
! 329: buttonState state = {0};
! 330:
! 331: assureCosmeticRNG;
! 332:
! 333: canceled = false;
! 334: initializeButtonState(&state, buttons, buttonCount, winX, winY, winWidth, winHeight);
! 335:
! 336: do {
! 337: // Update the display.
! 338: overlayDisplayBuffer(state.dbuf, NULL);
! 339:
! 340: // Get input.
! 341: nextBrogueEvent(&theEvent, true, false, false);
! 342:
! 343: // Process the input.
! 344: button = processButtonInput(&state, &canceled, &theEvent);
! 345:
! 346: // Revert the display.
! 347: overlayDisplayBuffer(state.rbuf, NULL);
! 348:
! 349: } while (button == -1 && !canceled);
! 350:
! 351: if (returnEvent) {
! 352: *returnEvent = theEvent;
! 353: }
! 354:
! 355: //overlayDisplayBuffer(dbuf, NULL); // hangs around
! 356:
! 357: restoreRNG;
! 358:
! 359: return button;
! 360: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Buttons.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / brogue-ce / src / brogue