void index_add_string(Index *self, char *str)
{
Document *doc = doc_new();
doc_add_field(doc, df_add_data(df_new(self->def_field), estrdup(str)));
index_add_doc(self, doc);
doc_destroy(doc);
}
Document* doc_load(const gchar* filename)
{
Document* doc = NULL;
FILE* f = fopen(filename, "r");
if (f) {
doc = doc_new();
doc->filename = g_strdup(filename);
size_t allocated_len = 0;
ssize_t len = 0;
gchar* str = NULL;
while ((len = getline(&str, &allocated_len, f)) > 0) {
GString* s = g_slice_new(GString);
if (str[len-1] == '\n')
str[--len] = '\0'; // strip newline
s->str = str;
s->len = len;
s->allocated_len = allocated_len;
g_ptr_array_insert(doc->lines, -1, s);
str = NULL;
allocated_len = 0;
}
}
return doc;
}
void index_add_array(Index *self, char **fields)
{
int i;
Document *doc = doc_new();
for (i = 0; i < ary_size(fields); i++) {
doc_add_field(doc, df_add_data(df_new(self->def_field),
estrdup(fields[i])));
}
index_add_doc(self, doc);
doc_destroy(doc);
}
static void add_sort_test_data(SortTestData *std, IndexWriter *iw)
{
Document *doc = doc_new();
doc_add_field(doc, df_add_data(df_new(search), std->search));
doc_add_field(doc, df_add_data(df_new(string), std->string));
doc_add_field(doc, df_add_data(df_new(integer), std->integer));
doc_add_field(doc, df_add_data(df_new(flt), std->flt));
sscanf(std->flt, "%f", &doc->boost);
iw_add_doc(iw, doc);
doc_destroy(doc);
}
static Document *prep_doc()
{
Document *doc = doc_new();
doc_add_field(
doc,
df_add_data(
df_new(I("content")),
estrdup("http://_____________________________________________________")
)
)->destroy_data = true;
return doc;
}
void prepare_filter_index(Store *store)
{
int i;
IndexWriter *iw;
FieldInfos *fis = fis_new(STORE_YES, INDEX_YES, TERM_VECTOR_NO);
num = intern("num");
date = intern("date");
flipflop = intern("flipflop");
struct FilterData data[FILTER_DOCS_SIZE] = {
{"0", "20040601", "on"},
{"1", "20041001", "off"},
{"2", "20051101", "on"},
{"3", "20041201", "off"},
{"4", "20051101", "on"},
{"5", "20041201", "off"},
{"6", "20050101", "on"},
{"7", "20040701", "off"},
{"8", "20050301", "on"},
{"9", "20050401", "off"}
};
index_create(store, fis);
fis_deref(fis);
iw = iw_open(store, whitespace_analyzer_new(false), NULL);
for (i = 0; i < FILTER_DOCS_SIZE; i++) {
Document *doc = doc_new();
doc->boost = (float)(i+1);
doc_add_field(doc, df_add_data(df_new(num), data[i].num));
doc_add_field(doc, df_add_data(df_new(date), data[i].date));
doc_add_field(doc, df_add_data(df_new(flipflop), data[i].flipflop));
iw_add_doc(iw, doc);
doc_destroy(doc);
}
iw_close(iw);
return;
}
void open_callb(GtkWidget *wdg, gpointer data) {
// Opens an existing file, loading it in a new document
// Dialog is modal and varies with application type
app_struct *app;
doc_wrapper *dw;
gchar *path_n_file;
GtkWidget *app_toolbar=NULL, *app_menu=NULL;
app = (app_struct *)data;
// If wdg is NULL, we are trying to open a file given on the command line
// doc_read calls doc_prepare_to_load
// doc_new (a few lines ahead) "fills up" the structure
// prepared by doc_prepare_to_load
if (wdg) { // Interactive creation
// In this case we commit the changes to the current
// document, if there are any
commit_or_reset (app->stack);
dw = doc_read(&path_n_file, app->types, app->docs, app->default_dir);
}
else { // File name given on the command line
path_n_file = app->file_on_cmdline;
dw = doc_prepare_to_load(path_n_file, app->types);
}
if (!dw)
return;
if (app->docs->current_doc)
if (app->docs->current_doc->creation_mode && INTEGRATED_INTERFACE)
cancel_create (app);
app->docs->last_doc = app->docs->current_doc;
app->docs->current_doc = dw;
// current_doc_data may contain a pointer to another document
app->docs->current_doc_data = NULL;
/************** CHECK: creating a creation dialog not required here **********/
// Create the dialogs needed for managing
// this particular document type, if needed
create_type_dialogs(app->types,
dw->type,
(gpointer) &app->docs->current_doc_data,
app->stack,
app->docs,
dw);
// Empty window + document creation
// Load the data from path_n_file into doc_wrapper struct
if (INTEGRATED_INTERFACE) {
app->docs->current_doc->tools_container = tools_container_new(app->types);
gtk_container_add(GTK_CONTAINER(app->docs->current_doc->tools_container), app->docs->current_doc->tools_dialog);
}
if (MENU_IN_DOC_WINDOW)
app_menu = (menu_new(NBCOMMANDS,commands, app->accel_group, (gpointer) app))->bar;
if (ICONS_IN_DOC_WINDOW)
app_toolbar = standard_toolbar_new(NBCOMMANDS,
commands,
app->tooltips,
app->window,
(gpointer) app,
GTK_ORIENTATION_HORIZONTAL,
GTK_TOOLBAR_ICONS,
FALSE);
if (!doc_new(app->docs, app->types, path_n_file, app->new_doc_count, &app->stack->commit_data, app_menu, app_toolbar))
cancel_create (app);
else {
ok_create_callb(NULL,data);
app->default_dir = app->docs->current_doc->dir;
if (!app->docs->current_doc->fname_tochoose)
app->docs->current_doc->if_modified = FALSE;
// If it's the first document, we have to re-position the window after building the dialogs
place_document_window(app->docs, app->types, app->types->tools_container);
}
}
void create_callb(GtkWidget *wdg, gpointer data) {
// Creates a new document with one of the allowed types for the current application
// Dialog is modal and varies with application type
GtkWidget *hbox, *button, *vbox, *app_toolbar=NULL, *app_menu=NULL;
app_struct *app;
app = (app_struct *)data;
// First we commit the changes to the current document, if there are any
commit_or_reset (app->stack);
app->docs->last_doc = app->docs->current_doc;
// Create a document window for the current doc
// Fill it with the display / controls for the current document type
app->docs->current_doc =
doc_wrapper_new("*", app->types->default_type->def_dir, app->types->default_type);
app->docs->current_doc->fname_tochoose = TRUE;
if (INTEGRATED_INTERFACE) {
// We pack the creation dialog with OK/CANCEL buttons here
app->docs->current_doc->creation_container = creation_container_new(app->types);
app->docs->current_doc->tools_container = tools_container_new(app->types);
// Commit_data && current_doc_data must not
// contain the last document pointer
set_commit_data (app->stack, NULL);
app->docs->current_doc_data = NULL;
create_type_dialogs(app->types,
app->docs->current_doc->type,
(gpointer) &app->docs->current_doc_data,
app->stack,
app->docs,
app->docs->current_doc);
hbox = gtk_hbox_new(TRUE,0);
gtk_widget_show(GTK_WIDGET(hbox));
button = gtk_button_new_with_label(_("OK"));
gtk_widget_show(GTK_WIDGET(button));
gtk_container_set_border_width(GTK_CONTAINER(button),DEF_PAD);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(ok_create_callb), (gpointer) app);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, DEF_PAD);
button = gtk_button_new_with_label(_("Cancel"));
gtk_widget_show(GTK_WIDGET(button));
gtk_container_set_border_width(GTK_CONTAINER(button),DEF_PAD);
gtk_signal_connect(GTK_OBJECT(button), "clicked",
GTK_SIGNAL_FUNC(cancel_create_callb), (gpointer) app);
gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, DEF_PAD);
vbox = gtk_vbox_new(FALSE,0);
gtk_widget_show(GTK_WIDGET(vbox));
gtk_box_pack_start(GTK_BOX(vbox), app->docs->current_doc->creation_dialog, TRUE, TRUE, DEF_PAD);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, DEF_PAD);
gtk_container_add(GTK_CONTAINER(app->docs->current_doc->creation_container),vbox);
// We don't forget the tools dialog, for later use
gtk_container_add(GTK_CONTAINER(app->docs->current_doc->tools_container), app->docs->current_doc->tools_dialog);
gtk_widget_hide(app->docs->current_doc->tools_container);
}
else { // Gimp style interface
if (!app->types->type_choice_dialog) {
// Current document and interface callbacks
// are linked in the following process
// We create a modal window, containing a hbox which packs:
// 1st widget from the top: file type choice toolbar
// option widgets, in the middle
// OK / Cancel button, at the bottom
// The interface is created once, so we keep the widgets embedded in their structs
// Creates the type choice dialog if inexistent
type_choice_dialog_new(app->types, (gpointer) app,
(gpointer) &app->docs->current_doc_data,
app->stack,
app->docs);
modal_dialog_showhide(app->types->creation_container,
app->types->type_choice_dialog,
_("New document"),
ok_create_callb,
cancel_create_callb,
(gpointer) app, 0, TRUE);
}
else { // Reactivates the modal dialog
type_choice_dialog_show(app->types);
gtk_widget_show(GTK_WIDGET(app->types->creation_container));
// ... set_uposition deprecated in GTK2, but I still have to find an alternative...
gtk_widget_set_uposition(GTK_WIDGET(app->types->creation_container),app->types->win_pos_x, app->types->win_pos_y);
gtk_grab_add(GTK_WIDGET(app->types->creation_container));
}
} // Emd Gimp style interface
if (MENU_IN_DOC_WINDOW)
app_menu = (menu_new(NBCOMMANDS,commands, app->accel_group, (gpointer) app))->bar;
if (ICONS_IN_DOC_WINDOW)
app_toolbar = standard_toolbar_new(NBCOMMANDS,
commands,
app->tooltips,
app->window,
(gpointer) app,
GTK_ORIENTATION_HORIZONTAL,
GTK_TOOLBAR_ICONS,
FALSE);
// Empty window + document creation
// printf("app->docs->doc_list dans CREATE_CALLB: %d\n",app->docs->doc_list);
doc_new(app->docs, app->types, NULL, app->new_doc_count, &app->stack->commit_data, app_menu, app_toolbar);
// Execute some defaults, if any
// 2008-01: Migrated to the type dialog level -doctype.c
// if (app->docs->current_doc->type->defaults)
// (*app->docs->current_doc->type->defaults)
// ((gpointer) &app->docs->current_doc_data);
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent)
{
// set working dir to executable work directory
QDir::setCurrent(QCoreApplication::applicationDirPath());
QString resDir = ResourceFinder::getPath();
//chess::FuncT *f = new chess::FuncT();
//f->run_pgn_speedtest();
//f->run_polyglot();
/*
f->run_pgnt();
f->run_pgn_scant();
*/
// reconstruct gameModel
this->gameModel = new GameModel();
this->gameModel->restoreGameState();
this->gameModel->getGame()->setTreeWasChanged(true);
this->boardViewController = new BoardViewController(gameModel, this);
this->moveViewController = new MoveViewController(gameModel, this);
this->moveViewController->setFocus();
this->engineViewController = new EngineView(gameModel, this);
engineViewController->setFocusPolicy(Qt::NoFocus);
moveViewController->setFocusPolicy(Qt::ClickFocus);
this->name = new QLabel();
name->setText("<b>Robert James Fisher - Reuben Fine</b><br/>New York(USA) 1963.03.??");
name->setAlignment(Qt::AlignCenter);
name->setBuddy(moveViewController);
QHBoxLayout *hbox_name_editHeader = new QHBoxLayout();
QPushButton *editHeader = new QPushButton();
QPixmap pxEditHeader(*this->fromSvgToPixmap(editHeader->iconSize(),resDir + "/res/icons/document-properties.svg"));
editHeader->setIcon(QIcon(pxEditHeader));
hbox_name_editHeader->addStretch(1);
hbox_name_editHeader->addWidget(this->name);
hbox_name_editHeader->addStretch(1);
hbox_name_editHeader->addWidget(editHeader);
this->uciController = new UciController();
this->modeController = new ModeController(gameModel, uciController, this);
this->editController = new EditController(gameModel, this);
this->fileController = new FileController(gameModel, this);
QSize btnSize = QSize(this->height()/19, this->height()/19);
QSize btnSizeLR = QSize(this->height()/14, this->height()/14);
QPushButton *left = new QPushButton();
QPushButton *right = new QPushButton();
QPushButton *beginning = new QPushButton();
QPushButton *end = new QPushButton();
left->setIconSize(btnSizeLR);
right->setIconSize(btnSizeLR);
beginning->setIconSize(btnSize);
end->setIconSize(btnSize);
QPixmap pxRight(*this->fromSvgToPixmap(right->iconSize(),resDir + "/res/icons/go-next.svg"));
QPixmap pxLeft(*this->fromSvgToPixmap(left->iconSize(),resDir + "/res/icons/go-previous.svg"));
QPixmap pxBeginning(*this->fromSvgToPixmap(left->iconSize(),resDir + "/res/icons/go-first.svg"));
QPixmap pxEnd(*this->fromSvgToPixmap(left->iconSize(),resDir + "/res/icons/go-last.svg"));
right->setIcon(QIcon(pxRight));
left->setIcon(QIcon(pxLeft));
beginning->setIcon(QIcon(pxBeginning));
end->setIcon(QIcon(pxEnd));
QWidget *mainWidget = new QWidget();
// setup the main window
// consisting of:
//
// <-------menubar---------------------------->
// <chess- -> <label w/ game data ->
// <board -> <moves_edit_view---------->
// <view -> <engine output view ->
QSizePolicy *spLeft = new QSizePolicy();
spLeft->setHorizontalStretch(1);
QSizePolicy *spRight = new QSizePolicy();
spRight->setHorizontalStretch(2);
QHBoxLayout *hbox_buttons = new QHBoxLayout();
hbox_buttons->addStretch(1);
hbox_buttons->addWidget(beginning);
hbox_buttons->addWidget(left);
hbox_buttons->addWidget(right);
hbox_buttons->addWidget(end);
hbox_buttons->addStretch(1);
QHBoxLayout *hbox_right_engine_buttons = new QHBoxLayout();
this->pbEngineOnOff = new OnOffButton(this); //new QPushButton("OFF");
this->lblMultiPv = new QLabel(this->tr("Lines:"), this);
this->spinMultiPv = new QSpinBox(this);
this->spinMultiPv->setRange(1,4);
this->spinMultiPv->setValue(1);
this->lblMultiPv->setBuddy(this->spinMultiPv);
QPushButton *editEngines = new QPushButton();
QPixmap pxEditEngines(*this->fromSvgToPixmap(editEngines->iconSize(),resDir + "/res/icons/document-properties.svg"));
editEngines->setIcon(QIcon(pxEditEngines));
hbox_right_engine_buttons->addWidget(pbEngineOnOff);
hbox_right_engine_buttons->addWidget(this->lblMultiPv);
hbox_right_engine_buttons->addWidget(this->spinMultiPv);
hbox_right_engine_buttons->addStretch(1);
hbox_right_engine_buttons->addWidget(editEngines);
QVBoxLayout *vbox_right = new QVBoxLayout();
vbox_right->addLayout(hbox_name_editHeader);
vbox_right->addWidget(moveViewController);
vbox_right->addLayout(hbox_buttons);
vbox_right->setStretch(0,1);
vbox_right->setStretch(1,4);
vbox_right->setStretch(2,1);
QVBoxLayout *vbox_left = new QVBoxLayout();
vbox_left->addWidget(boardViewController);
QWidget *lHboxWidget = new QWidget(this);
lHboxWidget->setLayout(vbox_left);
QWidget *rHboxWidget = new QWidget(this);
rHboxWidget->setLayout(vbox_right);
this->splitterLeftRight = new QSplitter(this);
splitterLeftRight->addWidget(lHboxWidget);
splitterLeftRight->addWidget(rHboxWidget);
QSplitterHandle *handleLeftRight = splitterLeftRight->handle(1);
QHBoxLayout *layoutSplitterLeftRight = new QHBoxLayout(handleLeftRight);
layoutSplitterLeftRight->setSpacing(0);
layoutSplitterLeftRight->setMargin(0);
QFrame *frameLeftRight = new QFrame(handleLeftRight);
frameLeftRight->setFrameShape(QFrame::VLine);
frameLeftRight->setFrameShadow(QFrame::Sunken);
layoutSplitterLeftRight->addWidget(frameLeftRight);
this->splitterTopDown = new QSplitter(this);
splitterTopDown->addWidget(splitterLeftRight);
splitterTopDown->setOrientation(Qt::Vertical);
QVBoxLayout *completeLayout = new QVBoxLayout();
completeLayout->addLayout(hbox_right_engine_buttons);
completeLayout->addWidget(engineViewController);
QWidget* bottomWidget = new QWidget(this);
bottomWidget->setLayout(completeLayout);
splitterTopDown->addWidget(bottomWidget);
QHBoxLayout *completeLayoutWithSplitter = new QHBoxLayout();
completeLayoutWithSplitter->addWidget(splitterTopDown);
QSplitterHandle *handleTopDown = splitterTopDown->handle(1);
QHBoxLayout *layoutSplitterTopDown = new QHBoxLayout(handleTopDown);
layoutSplitterTopDown->setSpacing(0);
layoutSplitterTopDown->setMargin(0);
QFrame *frameTopDown = new QFrame(handleTopDown);
frameTopDown->setFrameShape(QFrame::HLine);
frameTopDown->setFrameShadow(QFrame::Sunken);
layoutSplitterTopDown->addWidget(frameTopDown);
QMenu *m_game = this->menuBar()->addMenu(this->tr("Game"));
QAction* actionNewGame = m_game->addAction(this->tr("New..."));
QAction* actionOpen = m_game->addAction(this->tr("Open File"));
QAction* actionSaveAs = m_game->addAction("Save Current Game As");
m_game->addSeparator();
QAction* actionPrintGame = m_game->addAction(this->tr("Print Game"));
QAction* actionPrintPosition = m_game->addAction(this->tr("Print Position"));
QAction *save_diagram = m_game->addAction(this->tr("Save Position as Image..."));
m_game->addSeparator();
QAction *actionQuit = m_game->addAction(this->tr("Quit"));
actionNewGame->setShortcut(QKeySequence::New);
actionOpen->setShortcut(QKeySequence::Open);
//save_game->setShortcut(QKeySequence::Save);
actionSaveAs->setShortcut(QKeySequence::SaveAs);
actionPrintGame->setShortcut(QKeySequence::Print);
actionQuit->setShortcut(QKeySequence::Quit);
// EDIT MENU
QMenu *m_edit = this->menuBar()->addMenu(this->tr("Edit"));
QAction *actionCopyGame = m_edit->addAction(this->tr("Copy Game"));
QAction *actionCopyPosition = m_edit->addAction(this->tr("Copy Position"));
QAction *actionPaste = m_edit->addAction(this->tr("Paste"));
m_edit->addSeparator();
QAction *actionEditGameData = m_edit->addAction(this->tr("Edit Game Data"));
QAction *actionEnterPosition = m_edit->addAction(this->tr("&Enter Position"));
m_edit->addSeparator();
QAction *actionFlipBoard = m_edit->addAction(this->tr("&Flip Board"));
this->actionShowSearchInfo = m_edit->addAction(this->tr("Show Search &Info"));
QAction *actionColorStyle = m_edit->addAction(this->tr("Color Style..."));
QAction *actionResetLayout = m_edit->addAction(this->tr("Reset Layout"));
actionCopyGame->setShortcut(QKeySequence::Copy);
actionPaste->setShortcut(QKeySequence::Paste);
actionEnterPosition->setShortcut('e');
actionFlipBoard->setCheckable(true);
actionFlipBoard->setChecked(false);
actionShowSearchInfo->setCheckable(true);
actionShowSearchInfo->setChecked(true);
// MODE MENU
QMenu *m_mode = this->menuBar()->addMenu(this->tr("Mode"));
QActionGroup *mode_actions = new QActionGroup(this);
this->actionAnalysis = mode_actions->addAction(this->tr("&Analysis Mode"));
this->actionPlayWhite = mode_actions->addAction(this->tr("Play as &White"));
this->actionPlayBlack = mode_actions->addAction(this->tr("Play as &Black"));
this->actionEnterMoves = mode_actions->addAction(this->tr("Enter &Moves"));
actionAnalysis->setCheckable(true);
actionPlayWhite->setCheckable(true);
actionPlayBlack->setCheckable(true);
actionEnterMoves->setCheckable(true);
mode_actions->setExclusive(true);
m_mode->addAction(actionAnalysis);
m_mode->addAction(actionPlayWhite);
m_mode->addAction(actionPlayBlack);
m_mode->addAction(actionEnterMoves);
m_mode->addSeparator();
QAction* actionFullGameAnalysis = m_mode->addAction(this->tr("Full Game Analysis"));
QAction* actionEnginePlayout = m_mode->addAction(this->tr("Playout Position"));
m_mode->addSeparator();
QAction *actionSetEngines = m_mode->addAction(this->tr("Engines..."));
QShortcut *sc_analysis_mode = new QShortcut(QKeySequence(Qt::Key_A), this);
sc_analysis_mode->setContext(Qt::ApplicationShortcut);
QShortcut *sc_play_white = new QShortcut(QKeySequence(Qt::Key_W), this);
sc_play_white->setContext(Qt::ApplicationShortcut);
QShortcut *sc_play_black = new QShortcut(QKeySequence(Qt::Key_B), this);
sc_play_black->setContext(Qt::ApplicationShortcut);
QShortcut *sc_enter_move_mode_m = new QShortcut(QKeySequence(Qt::Key_M), this);
QShortcut *sc_enter_move_mode_esc = new QShortcut(QKeySequence(Qt::Key_Escape), this);
sc_enter_move_mode_m->setContext(Qt::ApplicationShortcut);
sc_enter_move_mode_esc->setContext(Qt::ApplicationShortcut);
// DATABASE MENU
QMenu *m_database = this->menuBar()->addMenu(this->tr("Database"));
QAction* actionDatabaseWindow = m_database->addAction(this->tr("Browse Games"));
QAction* actionLoadNextGame = m_database->addAction(this->tr("Next Game"));
QAction* actionLoadPreviousGame = m_database->addAction(this->tr("Previous Game"));
// HELP MENU
QMenu *m_help = this->menuBar()->addMenu(this->tr("Help "));
QAction *actionAbout = m_help->addAction(this->tr("About"));
QAction *actionHomepage = m_help->addAction(this->tr("Jerry-Homepage"));
// TOOLBAR
this->toolbar = addToolBar("main toolbar");
this->toolbar->setMovable(false);
//this->toolbar->setFixedHeight(72);
//this->toolbar->setIconSize(QSize(72,72));
QSize iconSize = toolbar->iconSize() * this->devicePixelRatio();
toolbar->setIconSize(iconSize);
if(SHOW_ICON_TEXT) {
toolbar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
}
QString doc_new(resDir + "/res/icons/document-new.svg");
QPixmap *tbNew = this->fromSvgToPixmap(iconSize,doc_new);
QAction *tbActionNew = toolbar->addAction(QIcon(*tbNew), this->tr("New"));
QString doc_open(resDir + "/res/icons/document-open.svg");
QPixmap *tbOpen = this->fromSvgToPixmap(iconSize, doc_open);
QAction *tbActionOpen = toolbar->addAction(QIcon(*tbOpen), this->tr("Open"));
QString doc_save(resDir + "/res/icons/document-save.svg");
QPixmap *tbSaveAs = this->fromSvgToPixmap(iconSize, doc_save);
QAction *tbActionSaveAs = toolbar->addAction(QIcon(*tbSaveAs), this->tr("Save As"));
QString doc_print(resDir + "/res/icons/document-print.svg");
QPixmap *tbPrint = this->fromSvgToPixmap(iconSize, doc_print);
QAction *tbActionPrint = toolbar->addAction(QIcon(*tbPrint), this->tr("Print"));
toolbar->addSeparator();
QString view_ref(resDir + "/res/icons/view-refresh.svg");
QPixmap *tbFlip = this->fromSvgToPixmap(iconSize, view_ref);
QAction *tbActionFlip = toolbar->addAction(QIcon(*tbFlip), this->tr("Flip Board"));
toolbar->addSeparator();
QString edt_cpy(resDir + "/res/icons/edit-copy-pgn.svg");
QPixmap *tbCopyGame = this->fromSvgToPixmap(iconSize, edt_cpy);
QAction *tbActionCopyGame = toolbar->addAction(QIcon(*tbCopyGame), this->tr("Copy Game"));
QString cpy_fen(resDir + "/res/icons/edit-copy-fen.svg");
QPixmap *tbCopyPosition = this->fromSvgToPixmap(iconSize, cpy_fen);
QAction *tbActionCopyPosition = toolbar->addAction(QIcon(*tbCopyPosition), this->tr("Copy Position"));
QString edt_pst(resDir + "/res/icons/edit-paste.svg");
QPixmap *tbPaste = this->fromSvgToPixmap(iconSize, edt_pst);
QAction *tbActionPaste = toolbar->addAction(QIcon(*tbPaste), this->tr("Paste"));
QString new_brd(resDir + "/res/icons/document-enter-position.svg");
QPixmap *tbEnterPosition = this->fromSvgToPixmap(iconSize, new_brd);
QAction *tbActionEnterPosition = toolbar->addAction(QIcon(*tbEnterPosition), this->tr("Enter Position"));
toolbar->addSeparator();
QString brd_ana(resDir + "/res/icons/emblem-system.svg");
QPixmap *tbAnalysis = this->fromSvgToPixmap(iconSize, brd_ana);
QAction *tbActionAnalysis = toolbar->addAction(QIcon(*tbAnalysis), this->tr("Full Analysis"));
toolbar->addSeparator();
QString db_icn(resDir + "/res/icons/database.svg");
QPixmap *tbDatabase = this->fromSvgToPixmap(iconSize, db_icn);
QAction *tbActionDatabase = toolbar->addAction(QIcon(*tbDatabase), this->tr("Browse Games"));
QString prevGame_icn(resDir + "/res/icons/go-previous.svg");
QPixmap *tbPrevGame = this->fromSvgToPixmap(iconSize, prevGame_icn);
QAction *tbActionPrevGame = toolbar->addAction(QIcon(*tbPrevGame), this->tr("Prev. Game"));
QString nextGame_icn(resDir + "/res/icons/go-next.svg");
QPixmap *tbNextGame = this->fromSvgToPixmap(iconSize, nextGame_icn);
QAction *tbActionNextGame = toolbar->addAction(QIcon(*tbNextGame), this->tr("Next Game"));
QWidget* spacer = new QWidget();
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
toolbar->addWidget(spacer);
QString hlp_clc(resDir + "/res/icons/help-browser.svg");
QPixmap *tbHelp = this->fromSvgToPixmap(iconSize, hlp_clc);
QAction *tbActionHelp = toolbar->addAction(QIcon(*tbHelp), this->tr("About"));
// toolbar shortcuts
QShortcut *sc_flip = new QShortcut(QKeySequence(Qt::Key_F), this);
sc_flip->setContext(Qt::ApplicationShortcut);
QShortcut *sc_enter_pos = new QShortcut(QKeySequence(Qt::Key_E), this);
sc_enter_pos->setContext(Qt::ApplicationShortcut);
/*
// FILE
// Game
QAction* actionNewGame = this->createAction("document-new", this->tr("New Game"), iconSize);
QAction* actionOpen = this->createAction("document-open", this->tr("Open File"), iconSize);
QAction* actionSaveAs = this->createAction("document-save", this->tr("Save Current\nGame As"), iconSize);
// Print
QAction* actionPrintGame = this->createAction("document-print", this->tr("Print Game"), iconSize);
QAction* actionPrintPosition = this->createAction("document-print-board", this->tr("Print Position"), iconSize);
// Layout
QAction* actionColorStyle = this->createAction("applications-graphics", this->tr("Board Style"), iconSize);
QAction* actionResetLayout = this->createAction("preferences-system-session", this->tr("Reset Layout"), iconSize);
// Quit
QAction* actionQuit = this->createAction("system-log-out", this->tr("Exit"), iconSize);
// Homepage
QAction* actionHomepage = this->createAction("internet-web-browser", this->tr("Homepage"), iconSize);
// Help (About)
QAction* actionAbout = this->createAction("help-browser", this->tr("About"), iconSize);
// START
// Game
QAction* actionPaste = this->createAction("edit-paste", this->tr("Paste\nGame/Position"), iconSize);
QAction* actionCopyGame = this->createAction("edit-copy-pgn", this->tr("Copy Game"), iconSizeSmall);
QAction* actionCopyPosition = this->createAction("edit-copy-fen", this->tr("Copy Position"), iconSizeSmall);
// Edit
QAction* actionEditGameData = this->createAction("edit-copy-fen", this->tr("Edit\nMeta Data"), iconSize);
QAction* actionEnterPosition = this->createAction("document-enter-position", this->tr("Setup\nNew Position"), iconSize);
QAction* actionFlipBoard = this->createAction("view-refresh", this->tr("Flip Board"), iconSize);
//QAction* actionShowSearchInfo = this->createAction("view-refresh", this->tr("Show\nSearch Info"), iconSize);
// Mode
QAction* actionAnalysis = this->createAction("edit-find", this->tr("Infinite\nAnalysis"), iconSize);
QAction* actionPlayWhite = this->createAction("play-white", this->tr("Play\nWhite"), iconSize);
QAction* actionPlayBlack = this->createAction("play-black", this->tr("Play\nBlack"), iconSize);
QAction* actionEnterMoves = this->createAction("text-pencil", this->tr("Enter\nMoves"), iconSize);
// Analysis
QAction* actionFullGameAnalysis = this->createAction("edit-find-replace", this->tr("Full\nGame Analysis"), iconSize);
QAction* actionEnginePlayout = this->createAction("dialog-information", this->tr("Engine\nPlayout"), iconSize);
// Database
QAction* actionDatabaseWindow = this->createAction("database", this->tr("Show\nDatabase"), iconSize);
QAction* actionLoadPreviousGame = this->createAction("go-previous", this->tr("Previous Game"), iconSizeSmall);
QAction* actionLoadNextGame = this->createAction("go-previous", this->tr("Next Game"), iconSizeSmall);
*/
mainWidget->setLayout(completeLayoutWithSplitter);
this->setCentralWidget(mainWidget);
QStatusBar *statusbar = this->statusBar();
statusbar->showMessage("");
this->setContextMenuPolicy(Qt::NoContextMenu);
// SIGNALS AND SLOTS
connect(actionNewGame, &QAction::triggered, this->fileController, &FileController::newGame);
connect(actionOpen, &QAction::triggered, this->fileController, &FileController::openGame);
connect(actionSaveAs, &QAction::triggered, this->fileController, &FileController::saveAsNewGame);
connect(actionPrintGame, &QAction::triggered, this->fileController, &FileController::printGame);
connect(actionPrintPosition, &QAction::triggered, this->fileController, &FileController::printPosition);
connect(actionColorStyle, &QAction::triggered, modeController, &ModeController::onOptionsClicked);
connect(actionResetLayout, &QAction::triggered, this, &MainWindow::resetLayout);
connect(actionQuit, &QAction::triggered, this, &QCoreApplication::quit);
connect(actionHomepage, &QAction::triggered, this, &MainWindow::goToHomepage);
connect(actionAbout, &QAction::triggered, this, &MainWindow::showAbout);
connect(actionPaste, &QAction::triggered, this->editController, &EditController::paste);
connect(actionCopyGame, &QAction::triggered, this->editController, &EditController::copyGameToClipBoard);
connect(actionCopyPosition, &QAction::triggered, this->editController, &EditController::copyPositionToClipBoard);
connect(actionEditGameData, &QAction::triggered, editController, &EditController::editHeaders);
connect(actionEnterPosition, &QAction::triggered, editController, &EditController::enterPosition);
connect(actionFlipBoard, &QAction::triggered, this->boardViewController, &BoardViewController::flipBoard);
//connect(actionShowSearchInfo, &QAction::triggered, this->engineViewController, &EngineView::flipShowEval);
connect(actionShowSearchInfo, &QAction::triggered, this->engineViewController, &EngineView::flipShowEval);
connect(actionAnalysis, &QAction::triggered, modeController, &ModeController::onActivateAnalysisMode);
connect(actionEnterMoves, &QAction::triggered, modeController, &ModeController::onActivateEnterMovesMode);
connect(actionPlayWhite, &QAction::triggered, modeController, &ModeController::onActivatePlayWhiteMode);
connect(actionPlayBlack, &QAction::triggered, modeController, &ModeController::onActivatePlayBlackMode);
connect(actionFullGameAnalysis, &QAction::triggered, modeController, &ModeController::onActivateGameAnalysisMode);
connect(actionEnginePlayout, &QAction::triggered, modeController, &ModeController::onActivatePlayoutPositionMode);
connect(actionSetEngines, &QAction::triggered, this->modeController, &ModeController::onSetEnginesClicked);
connect(actionDatabaseWindow, &QAction::triggered, fileController, &FileController::openDatabase);
connect(actionLoadNextGame, &QAction::triggered, fileController, &FileController::toolbarNextGameInPGN);
connect(actionLoadPreviousGame, &QAction::triggered, fileController, &FileController::toolbarPrevGameInPGN);
// toolbar buttons
connect(sc_flip, &QShortcut::activated, actionFlipBoard, &QAction::trigger);
connect(tbActionNew, &QAction::triggered, actionNewGame, &QAction::trigger);
connect(tbActionOpen, &QAction::triggered, actionOpen, &QAction::trigger);
connect(tbActionSaveAs, &QAction::triggered, actionSaveAs, &QAction::trigger);
connect(tbActionPrint, &QAction::triggered, actionPrintGame, &QAction::trigger);
connect(tbActionFlip, &QAction::triggered, actionFlipBoard, &QAction::trigger);
connect(tbActionCopyGame, &QAction::triggered, actionCopyGame, &QAction::trigger);
connect(tbActionCopyPosition, &QAction::triggered, actionCopyPosition, &QAction::trigger);
connect(tbActionPaste, &QAction::triggered, actionPaste, &QAction::trigger);
connect(tbActionEnterPosition, &QAction::triggered, actionEnterPosition, &QAction::trigger);
connect(tbActionAnalysis, &QAction::triggered, actionFullGameAnalysis, &QAction::trigger);
connect(tbActionDatabase, &QAction::triggered, actionDatabaseWindow, &QAction::trigger);
connect(tbActionPrevGame, &QAction::triggered, actionLoadPreviousGame, &QAction::trigger);
connect(tbActionNextGame, &QAction::triggered, actionLoadNextGame, &QAction::trigger);
connect(tbActionHelp, &QAction::triggered, actionAbout, &QAction::trigger);
// other signals
connect(gameModel, &GameModel::stateChange, this, &MainWindow::onStateChange);
connect(gameModel, &GameModel::stateChange, this->boardViewController, &BoardViewController::onStateChange);
connect(gameModel, &GameModel::stateChange, this->moveViewController, &MoveViewController::onStateChange);
connect(gameModel, &GameModel::stateChange, this->modeController, &ModeController::onStateChange);
connect(right, &QPushButton::clicked, this->moveViewController, &MoveViewController::onForwardClick);
connect(left, &QPushButton::clicked, this->moveViewController, &MoveViewController::onBackwardClick);
connect(editEngines, &QPushButton::clicked, this->modeController, &ModeController::onSetEnginesClicked);
connect(pbEngineOnOff, &QPushButton::toggled, this, &MainWindow::onEngineToggle);
connect(editHeader, &QPushButton::clicked, editController, &EditController::editHeaders);
//connect(enter_moves, &QAction::triggered, modeController, &ModeController::onActivateEnterMovesMode);
connect(uciController, &UciController::bestmove, modeController, &ModeController::onBestMove);
connect(uciController, &UciController::updateInfo, this->engineViewController, &EngineView::onNewInfo);
connect(uciController, &UciController::bestPv, modeController, &ModeController::onBestPv);
connect(uciController, &UciController::mateDetected, modeController, &ModeController::onMateDetected);
connect(uciController, &UciController::eval, modeController, &ModeController::onEval);
connect(fileController, &FileController::newGameEnterMoves, modeController, &ModeController::onActivateEnterMovesMode);
connect(fileController, &FileController::newGamePlayBlack, modeController, &ModeController::onActivatePlayBlackMode);
connect(fileController, &FileController::newGamePlayWhite, modeController, &ModeController::onActivatePlayWhiteMode);
connect(beginning, &QPushButton::pressed, this->moveViewController, &MoveViewController::onSeekToBeginning);
connect(end, &QPushButton::pressed, this->moveViewController, &MoveViewController::onSeekToEnd);
connect(this->spinMultiPv, qOverload<int>(&QSpinBox::valueChanged), this->modeController, &ModeController::onMultiPVChanged);
this->gameModel->setMode(MODE_ENTER_MOVES);
this->actionEnterMoves->setChecked(true);
gameModel->triggerStateChange();
this->resetLayout();
}
