/*
 * Main program.
 */
int main() {
    if (RANDOM_USE_SEED) {
        setRandomSeed(106);
    }

    setConsoleLocation(WINDOW_WIDTH + 6 * kMargin, 30);   // temporary
    setConsoleSize(450, 400);
    setConsoleEventOnClose(true);
    initializeGUI();
    Point guiLoc = gWindow->getLocation();
    GDimension guiSize = gWindow->getSize();
    setConsoleLocation(
        guiLoc.getX() + guiSize.getWidth() + kMargin,
        guiLoc.getY());

    // Main event loop to process events as they happen.
    while (true) {
        GEvent e = waitForEvent(ACTION_EVENT | MOUSE_EVENT | WINDOW_EVENT);
        if (e.getEventType() == MOUSE_CLICKED || e.getEventType() == MOUSE_MOVED) {
            processMouseEvent(GMouseEvent(e));
        } else if (e.getEventClass() == ACTION_EVENT) {
            processActionEvent(GActionEvent(e));
        } else if (e.getEventClass() == WINDOW_EVENT) {
            processWindowEvent(GWindowEvent(e));
        }
    }
    return 0;
}
Пример #2
0
/*
 * Main program.
 */
int main() {
    if (RANDOM_USE_SEED) {
        setRandomSeed(106);
    }
    
    intro();

    // create GUI window and position the console to its right
    setConsoleLocation(WorldGrid::WINDOW_WIDTH + 6 * WorldAbstract::WINDOW_MARGIN, 20);   // temporary
    // setConsoleSize(CONSOLE_WIDTH, CONSOLE_HEIGHT);
    setConsoleEventOnClose(true);
    
    TrailblazerGUI gui(WINDOW_TITLE);
    gui.snapConsoleLocation();

    // main event loop to process events as they happen
    while (true) {
        GEvent e = waitForEvent(ACTION_EVENT | MOUSE_EVENT | WINDOW_EVENT);
        if (e.getEventType() == MOUSE_CLICKED || e.getEventType() == MOUSE_MOVED) {
            gui.processMouseEvent(GMouseEvent(e));
        } else if (e.getEventClass() == ACTION_EVENT) {
            gui.processActionEvent(GActionEvent(e));
        } else if (e.getEventClass() == WINDOW_EVENT) {
            gui.processWindowEvent(GWindowEvent(e));
        }
    }
    return 0;
}
void test_front_back() {
    string colors[3] = {"blue", "red", "green"};
    const int objWidth = 100;
    const int objHeight = 100;
    const int x0 = 100;
    const int y0 = 100;
    const int dx = 40;
    const int dy = 0;
    GButton *forward = new GButton("Cycle Forward");
    GButton *backward = new GButton("Cycle Backward");
    GButton *stepUp = new GButton("Backmost +1");
    GButton *stepDown = new GButton("Frontmost -1");
    Vector<GObject *> objects;
    gw->addToRegion(forward, "south");
    gw->addToRegion(backward, "south");
    gw->addToRegion(stepUp, "south");
    gw->addToRegion(stepDown, "south");
    GCompound *compound = new GCompound();
    for (int i = 0; i < 3; i++) {
        GOval *oval = new GOval(x0 + i*dx, y0 + i*dy, objWidth, objHeight);
        if (i == 1)
            oval->setLocation(oval->getLocation().getX(), oval->getLocation().getY() + 50);
        oval->setFilled(true);
        oval->setFillColor(colors[i]);
        objects.add(oval);
        compound->add(oval);
    }
    gw->add(new GLabel("Click in window to end test", 10, 30));
    gw->add(compound);
    while(true) {
        GEvent e = waitForEvent(ACTION_EVENT | CLICK_EVENT);
        if (e.getEventType() == MOUSE_CLICKED)
            break;
        else if (e.getEventType() == ACTION_PERFORMED) {
            string cmd = ((GActionEvent) e).getActionCommand();
            if (cmd == "Cycle Forward")
                cycleObjects(objects);
            if (cmd == "Cycle Backward")
                cycleObjects(objects, false);
            if (cmd == "Backmost +1")
                moveBottomUp(objects);
            if (cmd == "Frontmost -1")
                moveTopDown(objects);
        }
    }

}
/* Main program. */
int main() {
  State state;
  initializeWindow();
  initializeState(state);
  drawWorld(state.world);
	
  /* Process events as they happen. */
  while (true) {
    GEvent e = waitForEvent(ACTION_EVENT | MOUSE_EVENT);
    if (e.getEventType() == MOUSE_CLICKED) {
      processMouseEvent(state, GMouseEvent(e));
    } else if (e.getEventClass() == ACTION_EVENT) {
      processActionEvent(state, GActionEvent(e));
    }
  }
}
/*
 * Runs and tests your floodFill function.
 */
void test_floodFill() {
    GObject::setAntiAliasing(false);
    floodFillWindow = new GWindow(FLOOD_WINDOW_WIDTH, FLOOD_WINDOW_HEIGHT);
    floodFillWindow->setWindowTitle("CS 106X Flood Fill");
    // floodFillWindow->center();
    // floodFillWindow->setRepaintImmediately(false);

    Map<string, int> colorMap;
    colorMap["Red"]    = 0x8c1515;   // Stanford red
    colorMap["Yellow"] = 0xeeee00;   // yellow
    colorMap["Blue"]   = 0x0000cc;   // blue
    colorMap["Green"]  = 0x00cc00;   // green
    colorMap["Purple"] = 0xcc00cc;   // purple
    colorMap["Orange"] = 0xff8800;   // orange
    Vector<string> colorVector = colorMap.keys();

    GLabel* fillLabel = new GLabel("Fill color:");
    GChooser* colorList = new GChooser();
    for (string key : colorMap) {
        colorList->addItem(key);
    }
    floodFillWindow->addToRegion(fillLabel, "SOUTH");
    floodFillWindow->addToRegion(colorList, "SOUTH");

    // use buffered image to store individual pixels
    if (floodFillPixels) {
        delete floodFillPixels;
        floodFillPixels = NULL;
    }
    floodFillPixels = new GBufferedImage(
                /* x */ 0,
                /* y */ 0,
                /* width */ FLOOD_WINDOW_WIDTH,
                /* height */ FLOOD_WINDOW_HEIGHT,
                /* rgb fill */ 0xffffff);

    // draw several random shapes
#ifdef FLOOD_FILL_RANDOM_SEED
    setRandomSeed(FLOOD_FILL_RANDOM_SEED);
#endif // FLOOD_FILL_RANDOM_SEED

    for (int i = 0; i < FLOOD_FILL_NUM_SHAPES; i++) {
        double x = randomInteger(0, FLOOD_WINDOW_WIDTH  - 100);
        double y = randomInteger(0, FLOOD_WINDOW_HEIGHT - 100);
        double w = randomInteger(20, 100);
        double h = randomInteger(20, 100);
        int color = colorMap[colorVector[randomInteger(0, colorVector.size() - 1)]];
        floodFillPixels->fillRegion(x, y, w, h, color);
    }
    floodFillWindow->add(floodFillPixels);

    // main event loop to process events as they happen
    while (true) {
        GEvent e = waitForEvent(MOUSE_EVENT | WINDOW_EVENT);
        if (e.getEventClass() == MOUSE_EVENT) {
            if (e.getEventType() != MOUSE_CLICKED) { continue; }
            colorList->setEnabled(false);
            GMouseEvent mouseEvent(e);
            string colorStr = colorList->getSelectedItem();
            int color = colorMap[colorStr];
            int mx = (int) mouseEvent.getX();
            int my = (int) mouseEvent.getY();
            cout << "Flood fill at (x=" << dec << mx << ", y=" << my << ")"
                 << " with color " << hex << setw(6) << setfill('0') << color
                 << dec << endl;
            floodFill(*floodFillPixels, mx, my, color);
            colorList->setEnabled(true);
            // floodFillWindow->repaint();
        } else if (e.getEventClass() == WINDOW_EVENT) {
            if (e.getEventType() == WINDOW_CLOSED) {
                // make sure that it was the flood fill window that got closed
                if (!floodFillWindow->isOpen() || !floodFillWindow->isVisible()) {
                    break;
                }
            }
        }
    }
    cout << resetiosflags(ios::fixed | ios::floatfield);
}
Пример #6
0
/*
 * Runs and tests your floodFill function.
 */
void test_floodFill() {
    GObject::setAntiAliasing(false);
    GWindow floodFillWindow(FLOOD_FILL_WINDOW_WIDTH, FLOOD_FILL_WINDOW_HEIGHT);
    floodFillWindow.setWindowTitle(FLOOD_FILL_WINDOW_TITLE);

    Map<string, int> colorMap;
    colorMap["Red"]    = 0x8c1515;   // Stanford red
    colorMap["Yellow"] = 0xeeee00;   // yellow
    colorMap["Blue"]   = 0x0000cc;   // blue
    colorMap["Green"]  = 0x00cc00;   // green
    colorMap["Purple"] = 0xcc00cc;   // purple
    colorMap["Orange"] = 0xff8800;   // orange
    Vector<string> colorVector = colorMap.keys();

    GLabel fillLabel("Fill color:");
    GChooser colorList;
    for (string key : colorMap) {
        colorList.addItem(key);
    }
    floodFillWindow.addToRegion(&fillLabel, "SOUTH");
    floodFillWindow.addToRegion(&colorList, "SOUTH");

    // use buffered image to store individual pixels
    GBufferedImage floodFillPixels(
                /* x */ 0,
                /* y */ 0,
                /* width */ FLOOD_FILL_WINDOW_WIDTH,
                /* height */ FLOOD_FILL_WINDOW_HEIGHT,
                /* rgb fill */ 0xffffff);
    
    // draw several random shapes
#ifdef FLOOD_FILL_RANDOM_SEED
    setRandomSeed(FLOOD_FILL_RANDOM_SEED);
#endif // FLOOD_FILL_RANDOM_SEED

    for (int i = 0; i < FLOOD_FILL_NUM_SHAPES; i++) {
        double w = randomInteger(FLOOD_FILL_MIN_RECT_SIZE, FLOOD_FILL_MAX_RECT_SIZE);
        double h = randomInteger(FLOOD_FILL_MIN_RECT_SIZE, FLOOD_FILL_MAX_RECT_SIZE);
        double x = randomInteger(0, FLOOD_FILL_WINDOW_WIDTH  - w);
        double y = randomInteger(0, FLOOD_FILL_WINDOW_HEIGHT - h - colorList.getHeight());
        int color = colorMap[colorVector[randomInteger(0, colorVector.size() - 1)]];
        floodFillPixels.fillRegion(x, y, w, h, color);
    }
    floodFillWindow.add(&floodFillPixels);

    // main event loop to process events as they happen
    while (true) {
        GEvent e = waitForEvent(MOUSE_EVENT | WINDOW_EVENT);
        if (e.getEventClass() == MOUSE_EVENT) {
            if (e.getEventType() != MOUSE_CLICKED) { continue; }
            colorList.setEnabled(false);
            GMouseEvent mouseEvent(e);
            string colorStr = colorList.getSelectedItem();
            int color = colorMap[colorStr];
            int mx = (int) mouseEvent.getX();
            int my = (int) mouseEvent.getY();
            cout << "Flood fill (x=" << dec << mx << ", y=" << my << "),"
                 << " color " << hex << setw(6) << setfill('0') << color
                 << dec << ": ";
            cout.flush();
            int pixelsColored = floodFill(floodFillPixels, mx, my, color);
            cout << pixelsColored << " pixels colored." << endl;
            colorList.setEnabled(true);
        } else if (e.getEventClass() == WINDOW_EVENT) {
            if (e.getEventType() == WINDOW_CLOSED) {
                // make sure that it was the flood fill window that got closed
                if (!floodFillWindow.isOpen() || !floodFillWindow.isVisible()) {
                    break;
                }
            }
        }
    }
    cout << resetiosflags(ios::fixed | ios::floatfield);
    
    cout << endl;
    cout << "Going to test flood fill exception handling." << endl;
    try {
        floodFill(floodFillPixels, -1, -2, 0x0);
        cout << "Fill (-1, -2) did not throw a proper exception." << endl;
    } catch (string) {
        cout << "Fill (-1, -2) threw an exception!" << endl;
    } catch (const char*) {
        cout << "Fill (-1, -2) threw an exception!" << endl;
    } catch (ErrorException) {
        cout << "Fill (-1, -2) threw an exception!" << endl;
    }
    try {
        floodFill(floodFillPixels, 3210, 4567, 0x0);
        cout << "Fill (3210, 4567) did not throw a proper exception." << endl;
    } catch (string) {
        cout << "Fill (3210, 4567) threw an exception!" << endl;
    } catch (const char*) {
        cout << "Fill (3210, 4567) threw an exception!" << endl;
    } catch (ErrorException) {
        cout << "Fill (3210, 4567) threw an exception!" << endl;
    }
}
void test_contains_and_getBounds() {
    bool useCompounds = false;
    int x0 = 350;
    int y0 = 300;
    Map<string, GObject*> shapeMap;
    GOval *oval = new GOval(x0, y0, 200, 100);
    GRoundRect *roundRect = new GRoundRect(x0, y0, 200, 100, 300);
    roundRect->setLineWidth(20);
    G3DRect *rect3d = new G3DRect(x0, y0, 200, 100, true);
    //rect3d->setLineWidth(5);
    rect3d->setFillColor("green");
    rect3d->setFilled(true);
    GPolygon *poly = new GPolygon;
    poly->addVertex(0, 0);
    poly->addEdge(200, 100);
    poly->addEdge(-200, 0);
    poly->setLocation(x0, y0);
    GPolygon *cpoly = new GPolygon;
    cpoly->addVertex(0, 0);
    cpoly->addEdge(200, 100);
    cpoly->addEdge(0, -100);
    cpoly->addEdge(-200, 100);
    cpoly->setLocation(x0, y0);
    GRect *rect = new GRect(x0, y0, 200, 100);
    GLine *line = new GLine(x0, y0, x0 + 200, y0 + 100);
    GLabel *label = new GLabel("Ostromantus", x0, y0);
    GArc *arc = new GArc(x0, y0, 350, 350, 0, 90);
    //arc->setLineWidth(5);
    arc->setColor("#44000000");
    GArc *filledArc = new GArc(x0, y0, 350, 100, 45, 225);
    filledArc->setFillColor("#88e0e0e0");
    filledArc->setFilled(true);
    GCompound *comp1 = new GCompound;
    comp1->setLocation(x0, y0);
    comp1->add(new GLabel("compound", 0, 15));
    GRect *bgRect1 = new GRect(0, 0);
    gw->add(bgRect1);
    bgRect1->setFillColor("#55dddddd");
    bgRect1->setFilled(true);
    GImage *image = new GImage("homer-transparent.png");
    image->setLocation(x0, y0);
    GCompound *comp = new GCompound;
    comp->setLocation(x0, y0);
    GRect *compRect = new GRect(20, 20, 100, 100);
    GOval *compOval = new GOval(90, 90, 150, 70);
    comp->add(compRect);
    comp->add(compOval);
    GButton *button = new GButton("Testo");
    button->setSize(200, 100);
    button->setLocation(x0, y0);
    shapeMap.put("oval", oval);
    shapeMap.put("rounded rectangle", roundRect);
    shapeMap.put("3D rectangle", rect3d);
    shapeMap.put("polygon", poly);
    shapeMap.put("crazy polygon", cpoly);
    shapeMap.put("rectangle", rect);
    shapeMap.put("line", line);
    shapeMap.put("arc", arc);
    shapeMap.put("filled arc", filledArc);
    shapeMap.put("label", label);
    shapeMap.put("image", image);
    shapeMap.put("compound", comp);
    shapeMap.put("button", button);

    GObject *currObj;
    GChooser *ch = new GChooser;
    ch->setActionCommand("chooser");
    ch->addItem("oval");
    ch->addItem("rounded rectangle");
    ch->addItem(("3D rectangle"));
    ch->addItem("polygon");
    ch->addItem("crazy polygon");
    ch->addItem("rectangle");
    ch->addItem("line");
    ch->addItem("arc");
    ch->addItem("filled arc");
    ch->addItem("label");
    ch->addItem("image");
    ch->addItem("compound");
    ch->addItem("button");
    ch->setSelectedItem("rectangle");
    currObj = rect;

    GButton *endButton = new GButton("End test");
    GButton *fillButton = new GButton("Auto-fill");
    GButton *rotateButton = new GButton("Rotate");
    GButton *scaleButton = new GButton("Scale");

    GCheckBox *compCheckbox = new GCheckBox("compounds");
    compCheckbox->setActionCommand("compounds");
    gw->addToRegion(compCheckbox, "north");
    gw->addToRegion(ch, "north");
    gw->addToRegion(rotateButton, "north");
    gw->addToRegion(scaleButton, "north");
    gw->addToRegion(fillButton, "north");
    gw->addToRegion(endButton, "north");

    while (true) {
        GEvent e = waitForEvent(ACTION_EVENT | MOUSE_EVENT);
        if (!e.isValid())
            continue;
        if (e.getEventClass() == ACTION_EVENT) {
            if (((GActionEvent) e).getActionCommand() == "End test")
                break;
            if (((GActionEvent) e).getActionCommand() == "compounds") {
                bgRect1->setVisible(compCheckbox->isSelected());
                useCompounds = compCheckbox->isSelected();
            }
            if (((GActionEvent) e).getActionCommand() == "Testo") {
                GPoint pt = button->getLocation();
                button->setLocation(pt.getX()-button->getWidth()-10, pt.getY());
                pause(1000);
                button->setLocation(pt);
            }
            if (((GActionEvent) e).getActionCommand() == "Auto-fill") {
                GRectangle bds = currObj->getBounds();
                int xmin = bds.getX();
                int ymin = bds.getY();
                int xmax = bds.getX() + bds.getWidth();
                int ymax = bds.getY() + bds.getHeight();
                int dx = useCompounds ? comp1->getX(): 0;
                int dy = useCompounds ? comp1->getY(): 0;
                for (int y = ymin; y < ymax; y+=1)
                    for (int x = xmin; x < xmax; x+=1) {
                        if (currObj->contains(x, y)) {
                            gw->setColor("red");
                            gw->fillOval(x + dx, y + dy, 1, 1);
                        } else {
                            gw->setColor("green");
                            gw->fillOval(x + dx, y + dy, 1, 1);
                        }
                    }
            }

            if (((GActionEvent) e).getActionCommand() == "Rotate") {
                currObj->rotate(45);
                if (useCompounds) {
                    bgRect1->setBounds(comp1->getBounds());
                }
            }
            if (((GActionEvent) e).getActionCommand() == "Scale") {
                currObj->scale(1.2, 0.8);
                if (useCompounds) {
                    bgRect1->setBounds(comp1->getBounds());
                }
            }
            if (((GActionEvent) e).getActionCommand() == "chooser") {
                string shape = ch->getSelectedItem();
                if (useCompounds) {
                    comp1->remove(currObj);
                    gw->remove(comp1);
                } else {
                    gw->remove(currObj);
                }
                gw->setColor("white");
                gw->fillRect(0, 0, gw->getCanvasWidth(), gw->getCanvasHeight());
                //drawGrid();
                gw->setColor("black");
                currObj = shapeMap.get(shape);
                if (useCompounds) {
                    gw->add(comp1);
                    comp1->add(currObj, 50, 50);
                    bgRect1->setBounds(comp1->getBounds());
                } else {
                    gw->add(currObj);
                }
                gw->drawOval(currObj->getX()-2, currObj->getY()-2, 4, 4);
            }
        } else if (e.getEventType() == MOUSE_CLICKED) {
            double x = ((GMouseEvent) e).getX();
            double y = ((GMouseEvent) e).getY();
            if (currObj->contains(x, y)) {
                gw->setColor("red");
                gw->fillOval(x, y, 1, 1);
            }
        }
    }
}
int main()
{
    int consoleX = 10;
    int consoleY = 10;
    setConsoleSize(600, 400);
    setConsoleFont("Monospaced-14");
    setConsoleExitProgramOnClose(true);
    setConsolePrintExceptions(true);

    extern int _mainFlags;
    if (_mainFlags & CONSOLE_FLAG) cout << "CONSOLE_FLAG set" << endl;
    if (_mainFlags & GRAPHICS_FLAG) cout << "GRAPHICS_FLAG set" << endl;
    if (_mainFlags & JBEMISC_FLAG) cout << "JBEMISC_FLAG set" << endl;

    GWindow gw(800, 300);

    setConsoleLocation(0, 300 + 50);
    gw.setColor("red");
    double winWidth = gw.getWidth();
    double winHeight = gw.getHeight();
    for (int i = 0; i < winWidth; i += 100)
        gw.drawLine(i, 0, i, winHeight);
    for (int j = 0; j < winHeight; j += 100)
        gw.drawLine(0, j, winWidth, j);
    gw.setColor("black");

    cout << "Screen size: " << getScreenWidth() << "x" << getScreenHeight() << endl;
    cout << "GWindow size: " << gw.getWidth() << "x" << gw.getHeight() << endl;
    cout << "Canvas size before adding interactors: " << gw.getCanvasWidth()
         << "x" << gw.getCanvasHeight() << endl;

    gw.setWindowTitle("Silly GUI Events Tester");

    GButton *button = new GButton("Shift Rectangle and Console");
    GButton *quitButton = new GButton("Quit");
    GCheckBox *cb = new GCheckBox("check here");
    GChooser *chooser = new GChooser();
    GSlider *slider = new GSlider(0, 100, 30);
    GTextField *textField = new GTextField();
    chooser->addItem("Up");
    chooser->addItem("Down");
    chooser->setSelectedItem("Up");
    chooser->setActionCommand("choosey");
    cb->setActionCommand("gurgle");
    slider->setActionCommand("slidey");
    textField->setActionCommand("texty");
    gw.setColor("red");

    GRect rect = GRect(40, 40, 60, 30);
    rect.setColor("#aa00cc98");
    cout << "rect.getColor(): " << rect.getColor() << endl;
    cout << "2309667788: " << convertRGBToColor(2309667788) << endl;
    cout << "magenta: " << hex << (unsigned) convertColorToRGB("gray") << endl;
    cout << "convertColorToRGB(#66ffc800): " << convertColorToRGB("#66ffc800") << endl;
    cout << "convertColorToRGB(#ffc800): " << convertColorToRGB("#ffc800") << endl;
    rect.setLineWidth(10);
    gw.add(&rect);

    gw.addToRegion(textField, "NORTH");
    gw.addToRegion(button, "SOUTH");
    gw.addToRegion(cb, "EAST");
    gw.addToRegion(chooser, "SOUTH");
    gw.addToRegion(quitButton, "south");
    gw.addToRegion(slider, "WEST");

    cout << "Canvas size after adding interactors: " << gw.getCanvasWidth()
         << "x" << gw.getCanvasHeight() << endl;

    gw.add(new GLabel("Click in here and type!", 300, 20));

    // Draw background grid for calibration
    for (int i = 0; i < winWidth; i += 100)
        gw.drawLine(i, 0, i, winHeight);
    for (int j = 0; j < winHeight; j += 100)
        gw.drawLine(0, j, winWidth, j);

    double cx = gw.getCanvasWidth() / 2;
    double cy = gw.getCanvasHeight() / 2;
    double r = 25;
    GArc *pacman = new GArc(cx - r, cy - r, 2 * r, 2 * r, 45, 270);
    pacman->setFilled(true);
    pacman->setFillColor(0x20cccccc); // fairly transparent gray
    gw.add(pacman);

    string ans = getLine("remove checkbox? (y/n) ");
    if (startsWith(ans, "y"))
        gw.removeFromRegion(cb, "EAST");

    ans = getLine("Clear console? (y/n) ");
    if (startsWith(ans, "y"))
        clearConsole();

    GButton *naked = new GButton("naked");
    gw.add(naked, 200, 180);

    cout.setf(ios::fixed);
    cout << dec;
    while (true)
    {
        GEvent e = waitForEvent();
        EventType type = e.getEventType();
        if (type == KEY_RELEASED || type == MOUSE_MOVED
                ||type == MOUSE_PRESSED||type == MOUSE_RELEASED)
            continue; // ignore these
        int eclass = e.getEventClass();
        int mods = e.getModifiers();
        string modstr = "";
        if (mods & SHIFT_DOWN) modstr += "SHIFT ";
        if (mods & CTRL_DOWN) modstr += "CTRL ";
        if (mods & META_DOWN) modstr += "META ";
        if (mods & ALT_DOWN) modstr += "ALT ";
        if (mods & ALT_GRAPH_DOWN) modstr += "ALTGRAPH ";
        if (mods & BUTTON1_DOWN) modstr += "BUT1 ";
        if (mods & BUTTON2_DOWN) modstr += "BUT2 ";
        if (mods & BUTTON3_DOWN) modstr += "BUT3 ";

        cout << e.toString() << endl;
        cout << "\tTime: " << setprecision(0) << e.getEventTime() << endl;
        cout << "\tModifiers: " << modstr << endl;

        if (eclass==ACTION_EVENT)
        {
            GActionEvent ae(e);
            string cmd = ae.getActionCommand();
            if (ae.getSource() == quitButton)
                exitGraphics();
            cout << "\tSource: " << ae.getSource()->toString() << " @ " << ae.getSource() << endl;
            cout << "\tActionCommand: " << cmd << endl;
            if (cmd == "choosey")
            {
                cout << "\tItem Selected: " << chooser->getSelectedItem() << endl;
            }
            if (cmd == "slidey")
            {
                cout << "\tCurrent Value: " << slider->getValue() << endl;
            }
            if (cmd == "texty")
            {
                cout << "\tText: " << textField->getText() << endl;
            }
            if (cmd == "gurgle")
            {
                cout << "\tSelected: " << boolToString(cb->isSelected()) << endl;
            }
            if (ae.getSource() == button)
            {
                GPoint p = rect.getLocation();
                if (chooser->getSelectedItem()=="Up")
                {
                    rect.setLocation(p.getX(), p.getY() - 5);
                    consoleX -= 10;
                    consoleY -= 10;
                    setConsoleLocation(consoleX, consoleY);
                    cout << "up" << endl;
                }
                else
                {
                    rect.setLocation(p.getX(), p.getY() + 5);
                    consoleX += 10;
                    consoleY += 10;
                    setConsoleLocation(consoleX, consoleY);
                    cout << "down" << endl;
                }
            }
        }
        if (eclass==WINDOW_EVENT)
        {
            GWindowEvent we(e);
            cout << "\tTitle: " << we.getGWindow().getWindowTitle() << endl;
            if (we.getEventType() == WINDOW_CLOSED) {
                break;
            }
        }
        if (eclass==MOUSE_EVENT)
        {
            GMouseEvent me(e);
            cout << "\tWindow Title: " << me.getGWindow().getWindowTitle() << endl;
            cout << "\t(x, y): " << "(" << me.getX() << ", " << me.getY() << ")" << endl;
        }
        if (eclass==KEY_EVENT)
        {
            GKeyEvent ke(e);
            cout << "\tWindow Title: " << ke.getGWindow().getWindowTitle() << endl;
            char keyChar = ke.getKeyChar();
            int keyCode = ke.getKeyCode();
            ostringstream oss;
            oss << "'";
            if (isprint(keyChar)) oss << keyChar;
            else oss << '\\' << oct << int(keyChar);
            oss << "'";
            cout << "\tKeyChar: " << oss.str() << endl;

            oss.str("");
            switch(keyCode)
            {
            case BACKSPACE_KEY:
                oss << "BACKSPACE_KEY";
                break;
            case TAB_KEY:
                oss << "TAB_KEY";
                break;
            case ENTER_KEY:
                oss << "ENTER_KEY";
                break;
            case CLEAR_KEY:
                oss << "CLEAR_KEY";
                break;
            case ESCAPE_KEY:
                oss << "ESCAPE_KEY";
                break;
            case PAGE_UP_KEY:
                oss << "PAGE_UP_KEY";
                break;
            case PAGE_DOWN_KEY:
                oss << "PAGE_DOWN_KEY";
                break;
            case END_KEY:
                oss << "END_KEY";
                break;
            case HOME_KEY:
                oss << "HOME_KEY";
                break;
            case LEFT_ARROW_KEY:
                oss << "LEFT_ARROW_KEY";
                break;
            case UP_ARROW_KEY:
                oss << "UP_ARROW_KEY";
                break;
            case RIGHT_ARROW_KEY:
                oss << "RIGHT_ARROW_KEY";
                break;
            case DOWN_ARROW_KEY:
                oss << "DOWN_ARROW_KEY";
                break;
            case F1_KEY:
                oss << "F1_KEY";
                break;
            case F2_KEY:
                oss << "F2_KEY";
                break;
            case F3_KEY:
                oss << "F3_KEY";
                break;
            case F4_KEY:
                oss << "F4_KEY";
                break;
            case F5_KEY:
                oss << "F5_KEY";
                break;
            case F6_KEY:
                oss << "F6_KEY";
                break;
            case F7_KEY:
                oss << "F7_KEY";
                break;
            case F8_KEY:
                oss << "F8_KEY";
                break;
            case F9_KEY:
                oss << "F9_KEY";
                break;
            case F10_KEY:
                oss << "F10_KEY";
                break;
            case F11_KEY:
                oss << "F11_KEY";
                break;
            case F12_KEY:
                oss << "F12_KEY";
                break;
            case DELETE_KEY:
                oss << "DELETE_KEY";
                break;
            case HELP_KEY:
                oss << "HELP_KEY";
                break;
            default:
                oss << "'";
                if (isprint(keyCode)) oss << char(keyCode);
                else oss << '\\' << oct << keyCode;
                oss << "'";
            }
            cout << "\tKeyCode: " << oss.str() << endl;
        }
    }
    return 0;
}
Пример #9
0
void gtableTest() {
    GWindow gw;
    gw.setTitle("GTable Test");
    
    GTable* table = new GTable(5, 3);
    // table->setColor("#0000cc");
    // table->setFont("Monospaced-Bold-20");
    // table->setHorizontalAlignment(GTable::Alignment::RIGHT);
    table->select(0, 1);
    gw.addToRegion(table, "NORTH");
    
//    GTable* table2 = new GTable(4, 2, 0, 0, 100, 400);
//    gw.addToRegion(table2, "EAST");
    
    GButton* buttget = new GButton("Get All");
    gw.addToRegion(buttget, "SOUTH");
    
    GButton* buttset = new GButton("Set All");
    gw.addToRegion(buttset, "SOUTH");
    
    GButton* buttclear = new GButton("Clear");
    gw.addToRegion(buttclear, "SOUTH");
    
    GButton* buttrowadd = new GButton("+R");
    gw.addToRegion(buttrowadd, "SOUTH");
    
    GButton* buttrowrem = new GButton("-R");
    gw.addToRegion(buttrowrem, "SOUTH");
    
    GButton* buttcoladd = new GButton("+C");
    gw.addToRegion(buttcoladd, "SOUTH");
    
    GButton* buttcolrem = new GButton("-C");
    gw.addToRegion(buttcolrem, "SOUTH");
    
    GButton* buttwidthadd = new GButton("+W");
    gw.addToRegion(buttwidthadd, "SOUTH");
    
    GButton* buttwidthrem = new GButton("-W");
    gw.addToRegion(buttwidthrem, "SOUTH");
    
    gw.setVisible(true);
    
    while (true) {
        GEvent event = waitForEvent(ACTION_EVENT | TABLE_EVENT | WINDOW_EVENT);
        if (event.getEventClass() == ACTION_EVENT) {
            GActionEvent actionEvent(event);
            if (actionEvent.getSource() == buttget) {
                for (int row = 0; row < table->numRows(); row++) {
                    for (int col = 0; col < table->numCols(); col++) {
                        cout << "R" << row << "C" << col << "=\"" << table->get(row, col) << "\" ";
                    }
                    cout << endl;
                }
                int row, col;
                table->getSelectedCell(row, col);
                cout << "selected: R" << row << "C" << col << endl;
            } else if (actionEvent.getSource() == buttset) {
                for (int row = 0; row < table->numRows(); row++) {
                    for (int col = 0; col < table->numCols(); col++) {
                        std::string value = "R" + integerToString(row) + "C" + integerToString(col);
                        table->set(row, col, value);
                    }
                }
                table->select(1, 2);
            } else if (actionEvent.getSource() == buttclear) {
                table->clear();
            } else if (actionEvent.getSource() == buttrowadd) {
                table->resize(table->numRows() + 1, table->numCols());
            } else if (actionEvent.getSource() == buttrowrem) {
                table->resize(table->numRows() - 1, table->numCols());
            } else if (actionEvent.getSource() == buttcoladd) {
                table->resize(table->numRows(), table->numCols() + 1);
            } else if (actionEvent.getSource() == buttcolrem) {
                table->resize(table->numRows(), table->numCols() - 1);
            } else if (actionEvent.getSource() == buttwidthadd) {
                table->setColumnWidth(1, table->getColumnWidth(1) + 20);
            } else if (actionEvent.getSource() == buttwidthrem) {
                table->setColumnWidth(1, table->getColumnWidth(1) - 20);
            }
        } else if (event.getEventClass() == WINDOW_EVENT) {
            if (event.getEventType() == WINDOW_CLOSED) {
                break;
            }
        } else if (event.getEventClass() == TABLE_EVENT) {
            GTableEvent tableEvent(event);
            std::cout << "cell updated: " << tableEvent.toString() << std::endl;
        }
    }
}