console.h

/*
 * File: console.h
 * ---------------
 * This file contains functions related to the library's graphical console window,
 * implemented using the Qt graphics library in native C++ instead of Java.
 * In general if you #include this file, it will implicitly enable the graphical
 * console.  If you don't want to do that, you should #define a flag named
 * __DONT_ENABLE_QT_GRAPHICAL_CONSOLE right before #include'ing this header.
 * Once the graphical console has been enabled, it cannot easily be turned off
 * again for that program.
 *
 * @author Marty Stepp
 * @version 2018/11/22
 * - added headless mode support
 * @version 2018/10/18
 * - fixed includes to avoid accidentally enabling GUI unintentionally
 * @version 2018/09/08
 * - added doc comments for new documentation generation
 * @version 2018/08/27
 * - cleaned up comments
 * @version 2018/08/23
 * - renamed to console.h to replace Java version
 * - separated out gconsolewindow.h/cpp
 * @version 2018/07/29
 * - menu, icons, hotkeys
 * @version 2018/07/26
 * - refactored GConsoleWindow class
 * @version 2018/07/15
 * - initial version, based on io/console.h
 */


#ifndef _console_h
#define _console_h

#include <string>

#ifndef SPL_HEADLESS_MODE
class GConsoleWindow;
struct GDimension;
struct GPoint;
#endif // SPL_HEADLESS_MODE

void clearConsole();

bool getConsoleClearEnabled();

/* GWindow::CloseOperation */ int getConsoleCloseOperation();

bool getConsoleEcho();

bool getConsoleEnabled();

bool getConsoleEventOnClose();

bool getConsoleExitProgramOnClose();

string getConsoleFont();

double getConsoleHeight();

#ifndef SPL_HEADLESS_MODE
GPoint getConsoleLocation();
#endif // SPL_HEADLESS_MODE

bool getConsoleLocationSaved();

bool getConsolePrintExceptions();

bool getConsoleSettingsLocked();

#ifndef SPL_HEADLESS_MODE
GDimension getConsoleSize();
#endif // SPL_HEADLESS_MODE

double getConsoleWidth();

#ifndef SPL_HEADLESS_MODE
GConsoleWindow* getConsoleWindow();
#endif // SPL_HEADLESS_MODE

string getConsoleWindowTitle();

void initializeQtGraphicalConsole();

// defined in gwindow.h/cpp
extern void pause(double milliseconds);

void setConsoleClearEnabled(bool value);

void setConsoleCloseOperation(/*GWindow::CloseOperation*/ int op);

void setConsoleEcho(bool echo);

void setConsoleErrorColor(const string& color);

void setConsoleEventOnClose(bool eventOnClose);

void setConsoleExitProgramOnClose(bool exitOnClose);

void setConsoleFont(const string& font);

void setConsoleLocation(double x, double y);

void setConsoleLocationSaved(bool value);

void setConsoleOutputColor(const string& color);

void setConsoleSettingsLocked(bool value);

void setConsoleSize(double width, double height);

void setConsoleWindowTitle(const string& title);

void shutdownConsole();

#endif // _console_h


/*
 * console.h is weird in that a student's program must be able to #include it
 * and then magically receive the graphical console instead of the standard one;
 * but we want other lib files to be able to include console.h to get the
 * function prototypes without actually turning the graphical console on.
 * To achieve this, we have the __DONT_ENABLE_QT_GRAPHICAL_CONSOLE flag that lib
 * files can set right before #include'ing console.h.  If they do so, it will
 * declare the prototypes but not initialize the graphical console.
 */
#ifndef __DONT_ENABLE_QT_GRAPHICAL_CONSOLE

extern void setConsoleEnabled(bool);

namespace sgl {
namespace qtgui {

#ifndef QtConsoleInitializer_created
#define QtConsoleInitializer_created

class QtConsoleInitializer_private {
public:
    /*
     * Code to initialize the library.
     * Implemented as a class constructor so that it will run during
     * static initialization phase, which happens before the student's
     * main function.
     */
    QtConsoleInitializer_private() {
        setConsoleEnabled(true);
    }
};

static QtConsoleInitializer_private __qt_console_init;
#endif // QtConsoleInitializer_created

} // namespace qtgui
} // namespace sgl

#endif // __DONT_ENABLE_QT_GRAPHICAL_CONSOLE