static void
gdaui_entry_string_start_editing (GtkCellEditable *iface, GdkEvent *event)
{
GdauiEntryString *mgstr;
g_return_if_fail (GDAUI_IS_ENTRY_STRING (iface));
mgstr = GDAUI_ENTRY_STRING (iface);
GdauiEntryStringPrivate *priv = gdaui_entry_string_get_instance_private (mgstr);
priv->editing_canceled = FALSE;
g_object_set (G_OBJECT (priv->entry), "has-frame", FALSE, "xalign", 0., NULL);
gtk_text_view_set_border_window_size (GTK_TEXT_VIEW (priv->view), GTK_TEXT_WINDOW_LEFT, 0);
gtk_text_view_set_border_window_size (GTK_TEXT_VIEW (priv->view), GTK_TEXT_WINDOW_RIGHT, 0);
gtk_text_view_set_border_window_size (GTK_TEXT_VIEW (priv->view), GTK_TEXT_WINDOW_TOP, 0);
gtk_text_view_set_border_window_size (GTK_TEXT_VIEW (priv->view), GTK_TEXT_WINDOW_BOTTOM, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->sw), GTK_SHADOW_NONE);
gtk_container_set_border_width (GTK_CONTAINER (priv->sw), 0);
gtk_cell_editable_start_editing (GTK_CELL_EDITABLE (priv->entry), event);
g_signal_connect (priv->entry, "editing-done",
G_CALLBACK (gtk_cell_editable_entry_editing_done_cb), mgstr);
g_signal_connect (priv->entry, "remove-widget",
G_CALLBACK (gtk_cell_editable_entry_remove_widget_cb), mgstr);
gtk_widget_grab_focus (priv->entry);
gtk_widget_queue_draw (GTK_WIDGET (mgstr));
}
G_MODULE_EXPORT void
add_border_windows (GtkTextView *text_view)
{
gtk_text_view_set_border_window_size (text_view, GTK_TEXT_WINDOW_LEFT, 30);
gtk_text_view_set_border_window_size (text_view, GTK_TEXT_WINDOW_RIGHT, 30);
gtk_text_view_set_border_window_size (text_view, GTK_TEXT_WINDOW_TOP, 30);
gtk_text_view_set_border_window_size (text_view, GTK_TEXT_WINDOW_BOTTOM, 30);
}
static void
dma_sparse_view_instance_init (DmaSparseView *view)
{
PangoFontDescription *font_desc;
view->priv = g_new0 (DmaSparseViewPrivate, 1);
view->priv->buffer = NULL;
view->priv->goto_window = NULL;
view->priv->goto_entry = NULL;
view->priv->show_line_numbers = TRUE;
view->priv->show_line_markers = TRUE;
view->priv->stamp = 0;
memset (view->priv->marker_pixbuf, 0, sizeof (view->priv->marker_pixbuf));
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (view), 2);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (view), 2);
g_signal_connect (view, "populate_popup",
G_CALLBACK (dma_sparse_view_populate_popup), view);
gtk_text_view_set_border_window_size (GTK_TEXT_VIEW (view),
GTK_TEXT_WINDOW_LEFT,
MIN_NUMBER_WINDOW_WIDTH);
font_desc = pango_font_description_from_string ("Monospace 10");
gtk_widget_modify_font (GTK_WIDGET (view), font_desc);
pango_font_description_free (font_desc);
dma_sparse_view_initialize_marker (view);
}
static VALUE
textview_set_border_window_size(VALUE self, VALUE wintype, VALUE size)
{
gtk_text_view_set_border_window_size(_SELF(self),
RVAL2GENUM(wintype, GTK_TYPE_TEXT_WINDOW_TYPE),
NUM2INT(size));
return self;
}
static void
update_gutter_size (GtkSourceGutter *gutter)
{
gint width = calculate_gutter_size (gutter, NULL);
gtk_text_view_set_border_window_size (GTK_TEXT_VIEW (gutter->priv->view),
gutter->priv->window_type,
width);
}
/**
* dma_sparse_view_set_show_line_markers:
* @view: a #DmaSparseView.
* @show: whether line markers should be displayed.
*
* If %TRUE line markers will be displayed beside the text.
*
**/
void
dma_sparse_view_set_show_line_markers (DmaSparseView *view, gboolean show)
{
g_return_if_fail (view != NULL);
g_return_if_fail (DMA_IS_SPARSE_VIEW (view));
show = (show != FALSE);
if (show)
{
if (!view->priv->show_line_markers)
{
/* Set left margin to minimum width if no margin is
visible yet. Otherwise, just queue a redraw, so the
expose handler will automatically adjust the margin. */
if (!view->priv->show_line_numbers)
gtk_text_view_set_border_window_size (GTK_TEXT_VIEW (view),
GTK_TEXT_WINDOW_LEFT,
MIN_NUMBER_WINDOW_WIDTH);
else
gtk_widget_queue_draw (GTK_WIDGET (view));
view->priv->show_line_markers = show;
g_object_notify (G_OBJECT (view), "show_line_markers");
}
}
else
{
if (view->priv->show_line_markers)
{
view->priv->show_line_markers = show;
/* force expose event, which will adjust margin. */
gtk_widget_queue_draw (GTK_WIDGET (view));
g_object_notify (G_OBJECT (view), "show_line_markers");
}
}
}
static gint
line_numbers_expose (GtkWidget *widget,
GdkEventExpose *event)
{
GtkTextView *text_view;
GdkWindow *win;
// GtkStyle *style;
PangoLayout *layout;
PangoAttrList *alist;
PangoAttribute *attr;
GArray *numbers;
GArray *pixels;
gint y1, y2;
gint count;
gint layout_width;
gint justify_width = 0;
gint i;
// gchar *str;
gchar str [8]; /* we don't expect more than ten million lines */
GdkGC *gc;
gint height;
if (line_number_visible){{{{{ // omit calculation
text_view = GTK_TEXT_VIEW (widget);
/* See if this expose is on the line numbers window */
/* left_win = gtk_text_view_get_window (text_view,
GTK_TEXT_WINDOW_LEFT);
right_win = gtk_text_view_get_window (text_view,
GTK_TEXT_WINDOW_RIGHT);
if (event->window == left_win)
{
type = GTK_TEXT_WINDOW_LEFT;
target = event->window;
}
else if (event->window == right_win)
{
type = GTK_TEXT_WINDOW_RIGHT;
target = right_win;
}
else
return FALSE;
*/
win = gtk_text_view_get_window (text_view,
GTK_TEXT_WINDOW_LEFT);
if (event->window != win)
return FALSE;
// style = gtk_style_copy (widget->style);
// style = gtk_style_copy (gtk_widget_get_default_style());
y1 = event->area.y;
y2 = y1 + event->area.height;
gtk_text_view_window_to_buffer_coords (text_view,
GTK_TEXT_WINDOW_LEFT,
0,
y1,
NULL,
&y1);
gtk_text_view_window_to_buffer_coords (text_view,
GTK_TEXT_WINDOW_LEFT,
0,
y2,
NULL,
&y2);
numbers = g_array_new (FALSE, FALSE, sizeof (gint));
pixels = g_array_new (FALSE, FALSE, sizeof (gint));
get_lines (text_view,
y1,
y2,
pixels,
numbers,
&count);
/* a zero-lined document should display a "1"; we don't need to worry about
scrolling effects of the text widget in this special case */
if (count == 0)
{
gint y = 0;
gint n = 0;
count = 1;
g_array_append_val (pixels, y);
g_array_append_val (numbers, n);
}
DV({g_print("Painting line numbers %d - %d\n",
g_array_index(numbers, gint, 0),
g_array_index(numbers, gint, count - 1)); });
layout = gtk_widget_create_pango_layout (widget, "");
// str = g_strdup_printf ("%d", gtk_text_buffer_get_line_count(text_view->buffer));
g_snprintf (str, sizeof (str),
"%d", MAX (99, gtk_text_buffer_get_line_count(text_view->buffer)));
pango_layout_set_text (layout, str, -1);
// g_free (str);
pango_layout_get_pixel_size (layout, &layout_width, NULL);
min_number_window_width = calculate_min_number_window_width(widget);
if (layout_width > min_number_window_width)
gtk_text_view_set_border_window_size (text_view,
GTK_TEXT_WINDOW_LEFT, layout_width + margin + submargin);
else {
// if ((gtk_text_view_get_border_window_size (text_view, GTK_TEXT_WINDOW_LEFT) - 5) > layout_width) {
gtk_text_view_set_border_window_size (text_view,
GTK_TEXT_WINDOW_LEFT, min_number_window_width + margin + submargin);
// }
justify_width = min_number_window_width - layout_width;
}
pango_layout_set_width (layout, layout_width);
pango_layout_set_alignment (layout, PANGO_ALIGN_RIGHT);
alist = pango_attr_list_new();
attr = pango_attr_foreground_new(
widget->style->text_aa->red,
widget->style->text_aa->green,
widget->style->text_aa->blue);
attr->start_index = 0;
attr->end_index = G_MAXUINT;
pango_attr_list_insert(alist, attr);
pango_layout_set_attributes(layout, alist);
pango_attr_list_unref(alist);
/* Draw fully internationalized numbers! */
i = 0;
while (i < count)
{
gint pos;
gtk_text_view_buffer_to_window_coords (text_view,
GTK_TEXT_WINDOW_LEFT,
0,
g_array_index (pixels, gint, i),
NULL,
&pos);
// str = g_strdup_printf ("%d", g_array_index (numbers, gint, i) + 1);
g_snprintf (str, sizeof (str),
"%d", g_array_index (numbers, gint, i) + 1);
pango_layout_set_text (layout, str, -1);
gtk_paint_layout (widget->style,
win,
GTK_WIDGET_STATE (widget),
FALSE,
NULL,
widget,
NULL,
#if GTK_CHECK_VERSION(2, 6, 0) // Is this solution???
layout_width + justify_width + margin / 2 + 1,
#else
layout_width + justify_width + margin / 2,
#endif
pos,
layout);
// g_free (str);
++i;
}
g_array_free (pixels, TRUE);
g_array_free (numbers, TRUE);
g_object_unref (G_OBJECT (layout));
// g_object_ref (G_OBJECT (style));
/* don't stop emission, need to draw children */
}}}}}
void EditFiles::viewFile(OovStringRef const fn, int lineNum)
{
FilePath fp;
fp.getAbsolutePath(fn, FP_File);
auto iter = std::find_if(mFileViews.begin(), mFileViews.end(),
[fp](std::unique_ptr<ScrolledFileView> const &fv) -> bool
{ return fv->mFilename.comparePaths(fp) == 0; });
if(iter == mFileViews.end())
{
GtkNotebook *book = nullptr;
if(putInMainWindow(fn))
book = mSourceBook;
else
book = mHeaderBook;
if(book)
{
GtkWidget *scrolled = gtk_scrolled_window_new(nullptr, nullptr);
GtkWidget *editView = gtk_text_view_new();
/// @todo - use make_unique when supported.
ScrolledFileView *scrolledView = new ScrolledFileView(mDebugger);
scrolledView->mFileView.init(GTK_TEXT_VIEW(editView), this);
OovStatus status = scrolledView->mFileView.openTextFile(fp);
if(status.needReport())
{
OovString err = "Unable to open file ";
err += fp;
status.report(ET_Error, err);
}
scrolledView->mScrolled = GTK_SCROLLED_WINDOW(scrolled);
scrolledView->mFilename = fp;
gtk_container_add(GTK_CONTAINER(scrolled), editView);
Gui::appendPage(book, scrolled,
newTabLabel(fp.getName(), scrolledView->getViewTopParent()));
gtk_widget_show_all(scrolled);
scrolledView->mLeftMargin.setupMargin(GTK_TEXT_VIEW(editView));
// Set up the windows to draw the line numbers in the left margin.
// GTK has changed, and different setups are required for different
// versions of GTK.
// This is not allowed for a text view
// gtk_widget_set_app_paintable(editView, true);
#if(USE_DRAW_LAYER)
overrideDrawLayer(editView);
// If the left window is not created, errors display, "Attempt to
// convert text buffer coordinates to coordinates for a nonexistent
// buffer or private child window of GtkTextView". So create a
// window that is only one pixel wide, and draw the line numbers
// on the main text view window.
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(editView),
GTK_TEXT_WINDOW_LEFT, 1);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(editView),
scrolledView->mLeftMargin.getMarginWidth());
#else
// The margin is drawn on the border window.
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(editView),
GTK_TEXT_WINDOW_LEFT, scrolledView->mLeftMargin.getMarginWidth());
g_signal_connect(editView, "draw", G_CALLBACK(onTextViewDraw), scrolledView);
#endif
g_signal_connect(editView, "focus_in_event",
G_CALLBACK(on_EditFiles_focus_in_event), NULL);
g_signal_connect(editView, "key_press_event",
G_CALLBACK(on_EditFiles_key_press_event), NULL);
g_signal_connect(editView, "button_press_event",
G_CALLBACK(on_EditFiles_button_press_event), NULL);
mFileViews.push_back(std::unique_ptr<ScrolledFileView>(scrolledView));
#if(DBG_EDITF)
sDbgFile.printflush("viewFile count %d, line %d\n", mFileViews.size(), lineNum);
#endif
iter = mFileViews.end()-1;
}
}
GtkNotebook *notebook = (*iter)->getBook();
if(notebook)
{
int pageIndex = getPageNumber(notebook, (*iter)->getTextView());
Gui::setCurrentPage(notebook, pageIndex);
// focus is set after the screen is displayed by onIdle
// gtk_widget_grab_focus(GTK_WIDGET((*iter).getTextView()));
#if(DBG_EDITF)
sDbgFile.printflush("viewFile %d\n", pageIndex);
#endif
if(lineNum > 1)
{
(*iter)->mDesiredLine = lineNum;
}
}
}
GtkWidget *create_main_view()
{
gint nmenu_items;
gint i;
LOG(LOG_DEBUG, "IN : create_main_view()");
dict_scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dict_scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
create_text_buffer();
main_view = gtk_text_view_new_with_buffer(text_buffer);
// You must continue to grab event.
// Otherwise, event stops when the cursor is at the area with no character.
g_signal_connect(G_OBJECT(main_view),"motion_notify_event",
G_CALLBACK(motion_notify_event), (gpointer)NULL);
g_signal_connect(G_OBJECT(main_view),"button_press_event",
G_CALLBACK(button_press_event), (gpointer)NULL);
g_signal_connect(G_OBJECT(main_view),"leave_notify_event",
G_CALLBACK(leave_notify_event), (gpointer)NULL);
gtk_text_view_set_editable(GTK_TEXT_VIEW(main_view), FALSE);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(main_view), 10);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(main_view), 10);
gtk_text_view_set_pixels_inside_wrap(GTK_TEXT_VIEW(main_view), line_space);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(main_view), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(main_view), GTK_WRAP_WORD);
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(main_view), GTK_TEXT_WINDOW_LEFT, 1);
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(main_view), GTK_TEXT_WINDOW_RIGHT, 1);
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(main_view), GTK_TEXT_WINDOW_TOP, 1);
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(main_view), GTK_TEXT_WINDOW_BOTTOM, 1);
if(line_space < 1)
line_space = 3;
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(main_view), line_space);
gtk_container_add (GTK_CONTAINER (dict_scroll), main_view);
nmenu_items = sizeof (text_menu_items) / sizeof (text_menu_items[0]);
for(i=0 ; i<nmenu_items ; i++){
text_menu_items[i].path = _(text_menu_items[i].path);
}
text_item_factory = gtk_item_factory_new (GTK_TYPE_MENU, "<text>",
NULL);
gtk_item_factory_create_items (text_item_factory, nmenu_items,
text_menu_items, NULL);
LOG(LOG_DEBUG, "OUT : create_main_view()");
return(dict_scroll);
}
int main (int argc, char *argv[])
{
//const std::string creatureDB[]={"pidgeot","gardevoir"}; - For creature catalog~~
//std::cout<<creatureDB[0];
/* Initialize GTK+ */
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL);
gtk_init (&argc, &argv);
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
/* Main window configuration */
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (win), false);
gtk_widget_set_size_request(win,windowWidth,windowHeight);
gtk_container_set_border_width (GTK_CONTAINER (win), 0);
gtk_window_set_title (GTK_WINDOW (win), "Pokemon");
gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
gtk_widget_realize (win);
g_signal_connect (win, "destroy", gtk_main_quit, NULL);
gtk_window_set_icon_from_file(GTK_WINDOW(win),"images/winIcon.png",NULL);
//gtk_window_set_decorated (GTK_WINDOW(win),FALSE); //Óáèðàåò ñòàíäàðòíîå îôîðìëåíèå îêíà windows
/* Initializing objects */
zeBigContainer = gtk_box_new (GTK_ORIENTATION_VERTICAL,0);
zeBigContainerOverlay = gtk_overlay_new();
topPart = gtk_box_new (GTK_ORIENTATION_HORIZONTAL,0);
topPartCenter = gtk_alignment_new (0.5,0.5,1,1);
topPartLeft = gtk_box_new (GTK_ORIENTATION_VERTICAL,0);
topPartCenter = gtk_box_new (GTK_ORIENTATION_HORIZONTAL,0);
topPartRight = gtk_box_new (GTK_ORIENTATION_VERTICAL,0);
bottomPart = gtk_box_new (GTK_ORIENTATION_HORIZONTAL,0);
buttons = gtk_grid_new ();
dialogScrollFrame = gtk_scrolled_window_new(NULL,NULL);
dialogText = gtk_text_view_new ();
dialogBuffer = gtk_text_buffer_new (NULL);
button1 = gtk_button_new ();
button2 = gtk_button_new ();
button3 = gtk_button_new ();
button4 = gtk_button_new_with_label ("Restart");
button5 = gtk_button_new_with_label ("Back to choosing screen");
topMidPart = gtk_image_new_from_file ("images/topPic.jpg");
IMGBackground = gtk_image_new_from_file ("images/pokeBackground.jpg");
leftImage = gtk_image_new_from_file ("images/filler.PNG");
rightImage = gtk_image_new_from_file ("images/filler.PNG");
leftBar = gtk_progress_bar_new ();
rightBar = gtk_progress_bar_new ();
/* Setting dialogText */
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(dialogText), GTK_TEXT_WINDOW_LEFT, 5);
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(dialogText), GTK_TEXT_WINDOW_BOTTOM, 20);
gtk_text_view_set_border_window_size(GTK_TEXT_VIEW(dialogText), GTK_TEXT_WINDOW_TOP, 5);
gtk_text_view_set_editable(GTK_TEXT_VIEW(dialogText), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(dialogText), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(dialogText),GTK_WRAP_WORD);
/* Setting progress bars */
gtk_progress_bar_set_inverted(GTK_PROGRESS_BAR(rightBar),TRUE);
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(leftBar),TRUE);
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(rightBar),TRUE);
/* Various initializations */
gtk_box_set_homogeneous((GtkBox*)topPartCenter,TRUE);
gtk_box_set_homogeneous((GtkBox*)topPart,TRUE);
gtk_box_set_homogeneous((GtkBox*)bottomPart,TRUE);
gtk_box_set_homogeneous((GtkBox*)zeBigContainer,TRUE);
gtk_grid_set_row_homogeneous((GtkGrid*)buttons,TRUE);
gtk_grid_set_column_homogeneous((GtkGrid*)buttons,TRUE);
gtk_grid_set_row_spacing((GtkGrid*)buttons,12);
gtk_grid_set_column_spacing((GtkGrid*)buttons,12);
g_object_set (buttons,"margin",12,NULL);
g_object_set (topPart,"margin",12,NULL);
gtk_container_set_border_width(GTK_CONTAINER(dialogScrollFrame),5);
//gtk_box_set_child_packing((GtkBox*)zeBigContainer,bottomPart,gTRUE,gTRUE,100,GTK_PACK_START);
gtk_text_view_set_buffer (GTK_TEXT_VIEW(dialogText), dialogBuffer);
gtk_text_buffer_set_text(dialogBuffer, "", -1);
//gtk_text_buffer_get_iter_at_offset (dialogBuffer, &lastCharIter, -1);
gtk_text_buffer_get_end_iter(dialogBuffer, &endIter);
fontDesc = pango_font_description_from_string("Consolas");
gtk_widget_override_font(dialogText,fontDesc);
endMark = gtk_text_mark_new ("endMark",FALSE);
endMark = gtk_text_buffer_get_mark(dialogBuffer,"insert");
gtk_button_set_always_show_image(GTK_BUTTON(button1),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(button2),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(button3),TRUE);
/* Building objects */
gtk_container_add (GTK_CONTAINER(win),zeBigContainerOverlay);
gtk_overlay_add_overlay(GTK_OVERLAY(zeBigContainerOverlay),zeBigContainer);
gtk_container_add (GTK_CONTAINER(zeBigContainerOverlay),IMGBackground);
gtk_container_add (GTK_CONTAINER(zeBigContainer),topPart);
gtk_container_add (GTK_CONTAINER(zeBigContainer),bottomPart);
gtk_container_add (GTK_CONTAINER(topPart),topPartLeft); // Â topPartLeft âñòàâëÿòü ëåâûé áàð
gtk_container_add (GTK_CONTAINER(topPartLeft),leftBar);
gtk_container_add (GTK_CONTAINER(topPartLeft),leftImage);
gtk_container_add (GTK_CONTAINER(topPart),topPartCenter);
gtk_container_add (GTK_CONTAINER(topPart),topPartRight); // â topPartRight - ïðàâûé...
gtk_container_add (GTK_CONTAINER(topPartRight),rightBar);
gtk_container_add (GTK_CONTAINER(topPartRight),rightImage);
gtk_container_add (GTK_CONTAINER(topPartCenter),topMidPart);
gtk_container_add (GTK_CONTAINER(bottomPart),dialogScrollFrame);
gtk_container_add (GTK_CONTAINER(dialogScrollFrame),dialogText);
gtk_container_add (GTK_CONTAINER(bottomPart),buttons);
gtk_grid_attach (GTK_GRID(buttons),button1, 1,1,1,1);
gtk_grid_attach (GTK_GRID(buttons),button2, 1,2,1,1);
gtk_grid_attach (GTK_GRID(buttons),button3, 1,3,1,1);
gtk_grid_attach (GTK_GRID(buttons),button4, 1,4,1,1);
gtk_grid_attach (GTK_GRID(buttons),button5, 1,5,1,1);
/* Signal connects and some shiatd */
g_signal_connect(G_OBJECT(button1), "clicked", Cast1, NULL);
g_signal_connect(G_OBJECT(button2), "clicked", Cast2, NULL);
g_signal_connect(G_OBJECT(button3), "clicked", Cast3, NULL);
g_signal_connect(G_OBJECT(button4), "clicked", combatStart, NULL);
g_signal_connect(G_OBJECT(button5), "clicked", backToChoosingScreen,NULL);
/* Creature chooser window configuration */ // TO BE CONTINUED..........................................................................
/* Window creation/configuration (win2) */
win2win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (win2win), false);
gtk_widget_set_size_request(win2win,windowWidth,windowHeight);
gtk_window_set_title (GTK_WINDOW (win2win), "Pokemon creature chooser");
gtk_window_set_position (GTK_WINDOW (win2win), GTK_WIN_POS_CENTER);
gtk_widget_realize (win2win);
g_signal_connect (win2win, "destroy", gtk_main_quit, NULL);
gtk_window_set_icon_from_file(GTK_WINDOW(win2win),"images/winIcon.png",NULL);
/* Initializing objects (win2) */
win2topLabel = gtk_image_new_from_file("images/logo.png");
//win2topLabel = gtk_label_new("");
//gtk_label_set_markup(GTK_LABEL(win2topLabel),"<small>Small</small><big>Bold</big>");
win2BigContainer = gtk_grid_new();
win2BigContainerOverlay = gtk_overlay_new ();
win2TopPart = gtk_grid_new ();
win2MiddlePart = gtk_box_new (GTK_ORIENTATION_HORIZONTAL,0);
win2BottomPart = gtk_grid_new();
win2BackgroundIMG = gtk_image_new_from_file ("images/pokeBackground.jpg");
win2button1 = gtk_button_new_with_label(">>Switch Screens<<");
win2button2 = gtk_button_new_with_label("Exit");
win2buttonReset = gtk_button_new_with_label("Reset");
win2creatureIcon1 = gtk_button_new();
win2creatureIcon2 = gtk_button_new();
win2creatureIcon3 = gtk_button_new();
win2creatureIcon4 = gtk_button_new();
win2creatureIcon5 = gtk_button_new();
win2creatureIcon1IMG = gtk_image_new_from_file("images/ImagePidgeotSmall.png");
win2creatureIcon2IMG = gtk_image_new_from_file("images/ImageGardevoirSmall.png");
win2creatureIcon3IMG = gtk_image_new_from_file("images/ImageArcanineSmall.png");
win2creatureIcon4IMG = gtk_image_new_from_file("images/ImagePikachuSmall.png");
win2creatureIcon5IMG = gtk_image_new_from_file("images/ImageFishSmall.png");
win2ImageVersus = gtk_image_new_from_file ("images/versus.png");
win2MiddleFirst = gtk_image_new_from_file ("images/facelessVoid.png");
win2MiddleSecond = gtk_image_new_from_file ("images/facelessVoid.png");
/* Various initializations (win2) */
gtk_grid_set_row_homogeneous((GtkGrid*)win2BigContainer,TRUE);
gtk_grid_set_column_homogeneous((GtkGrid*)win2BigContainer,TRUE);
gtk_grid_set_row_spacing((GtkGrid*)win2BigContainer,12);
gtk_grid_set_column_spacing((GtkGrid*)win2BigContainer,12);
//g_object_set (win2BigContainer,"margin",12,NULL);
gtk_grid_set_row_homogeneous((GtkGrid*)win2BottomPart,TRUE);
gtk_grid_set_column_homogeneous((GtkGrid*)win2BottomPart,TRUE);
gtk_grid_set_row_spacing((GtkGrid*)win2BottomPart,12);
gtk_grid_set_column_spacing((GtkGrid*)win2BottomPart,12);
g_object_set (win2BottomPart,"margin",12,NULL);
gtk_grid_set_row_homogeneous((GtkGrid*)win2TopPart,TRUE);
gtk_grid_set_column_homogeneous((GtkGrid*)win2TopPart,TRUE);
gtk_grid_set_row_spacing((GtkGrid*)win2TopPart,12);
gtk_grid_set_column_spacing((GtkGrid*)win2TopPart,12);
g_object_set (win2TopPart,"margin",12,NULL);
gtk_box_set_homogeneous(GTK_BOX(win2MiddlePart),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(win2creatureIcon1),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(win2creatureIcon2),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(win2creatureIcon3),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(win2creatureIcon4),TRUE);
gtk_button_set_always_show_image(GTK_BUTTON(win2creatureIcon5),TRUE);
gtk_button_set_image(GTK_BUTTON(win2creatureIcon1),win2creatureIcon1IMG);
gtk_button_set_image(GTK_BUTTON(win2creatureIcon2),win2creatureIcon2IMG);
gtk_button_set_image(GTK_BUTTON(win2creatureIcon3),win2creatureIcon3IMG);
gtk_button_set_image(GTK_BUTTON(win2creatureIcon4),win2creatureIcon4IMG);
gtk_button_set_image(GTK_BUTTON(win2creatureIcon5),win2creatureIcon5IMG);
/* Building objects (win2) */
gtk_container_add (GTK_CONTAINER(win2win),win2BigContainerOverlay);
gtk_overlay_add_overlay(GTK_OVERLAY(win2BigContainerOverlay),win2BigContainer);
gtk_container_add (GTK_CONTAINER(win2BigContainerOverlay),win2BackgroundIMG);
gtk_grid_attach(GTK_GRID(win2BigContainer),win2topLabel,1,1,1,2);//1
gtk_grid_attach(GTK_GRID(win2BigContainer),win2TopPart,1,2,1,3);//3
gtk_grid_attach(GTK_GRID(win2TopPart),win2creatureIcon1,1,1,1,1);
gtk_grid_attach(GTK_GRID(win2TopPart),win2creatureIcon2,2,1,1,1);
gtk_grid_attach(GTK_GRID(win2TopPart),win2creatureIcon3,3,1,1,1);
gtk_grid_attach(GTK_GRID(win2TopPart),win2creatureIcon4,4,1,1,1);
gtk_grid_attach(GTK_GRID(win2TopPart),win2creatureIcon5,5,1,1,1);
gtk_grid_attach(GTK_GRID(win2BigContainer),win2MiddlePart,1,5,1,3);//3
gtk_grid_attach(GTK_GRID(win2BigContainer),win2BottomPart,1,8,1,3);//3
gtk_container_add (GTK_CONTAINER(win2MiddlePart),win2MiddleFirst);
gtk_container_add (GTK_CONTAINER(win2MiddlePart),win2ImageVersus);
gtk_container_add (GTK_CONTAINER(win2MiddlePart),win2MiddleSecond);
gtk_grid_attach (GTK_GRID(win2BottomPart),win2button1, 1,1,3,1);
gtk_grid_attach (GTK_GRID(win2BottomPart),win2buttonReset,4,1,1,1);
gtk_grid_attach (GTK_GRID(win2BottomPart),win2button2, 5,1,1,1);
/* Signal connects (win2) */
g_signal_connect (G_OBJECT(win2button1),"clicked",win2StartGame,NULL);
g_signal_connect (G_OBJECT(win2button2),"clicked",gtk_main_quit,NULL);
g_signal_connect (G_OBJECT(win2creatureIcon1),"clicked",win2pidgeotSelect,NULL);
g_signal_connect (G_OBJECT(win2creatureIcon2),"clicked",win2gardevoirSelect,NULL);
g_signal_connect (G_OBJECT(win2creatureIcon3),"clicked",win2arcanineSelect,NULL);
g_signal_connect (G_OBJECT(win2creatureIcon4),"clicked",win2pikachuSelect,NULL);
g_signal_connect (G_OBJECT(win2creatureIcon5),"clicked",win2mightyfishSelect,NULL);
g_signal_connect (G_OBJECT(win2buttonReset),"clicked",win2CharReset,NULL);
/* Other stuff */
srand(time(NULL));
write ("___________________________________________________\n");
/* Enter the main loop */
gtk_widget_show_all (win2win);
gtk_main ();
return 0;
};
static void
dma_sparse_view_paint_margin (DmaSparseView *view,
GdkEventExpose *event)
{
GtkTextView *text_view;
GdkWindow *win;
PangoLayout *layout;
gint y1, y2;
gint y, height;
gchar str [16];
gint margin_width;
gint margin_length;
gint text_width;
DmaSparseIter buf_iter;
GtkTextIter text_iter;
guint prev_address = G_MAXUINT;
text_view = GTK_TEXT_VIEW (view);
if (!view->priv->show_line_numbers && !view->priv->show_line_markers)
{
gtk_text_view_set_border_window_size (text_view,
GTK_TEXT_WINDOW_LEFT,
0);
return;
}
win = gtk_text_view_get_window (text_view,
GTK_TEXT_WINDOW_LEFT);
y1 = event->area.y;
y2 = y1 + event->area.height;
/* get the extents of the line printing */
gtk_text_view_window_to_buffer_coords (text_view,
GTK_TEXT_WINDOW_LEFT,
0,
y1,
NULL,
&y1);
gtk_text_view_window_to_buffer_coords (text_view,
GTK_TEXT_WINDOW_LEFT,
0,
y2,
NULL,
&y2);
/* set size. */
g_snprintf (str, sizeof (str), "0x%X", G_MAXUINT);
margin_length = strlen(str) - 2;
layout = gtk_widget_create_pango_layout (GTK_WIDGET (view), str);
pango_layout_get_pixel_size (layout, &text_width, NULL);
pango_layout_set_width (layout, text_width);
pango_layout_set_alignment (layout, PANGO_ALIGN_RIGHT);
/* determine the width of the left margin. */
if (view->priv->show_line_numbers)
margin_width = text_width + 4;
else
margin_width = 0;
if (view->priv->show_line_markers)
margin_width += GUTTER_PIXMAP;
g_return_if_fail (margin_width != 0);
gtk_text_view_set_border_window_size (GTK_TEXT_VIEW (text_view),
GTK_TEXT_WINDOW_LEFT,
margin_width);
/* Display all addresses */
dma_sparse_iter_copy (&buf_iter, &view->priv->start);
gtk_text_buffer_get_start_iter (gtk_text_view_get_buffer (text_view), &text_iter);
/* Skip line while position doesn't need to be repaint */
gtk_text_view_get_line_yrange (text_view, &text_iter, &y, &height);
if (y < y1)
{
do
{
if (!dma_sparse_iter_forward_lines (&buf_iter, 1)) return;
if (!gtk_text_iter_forward_line (&text_iter)) return;
gtk_text_view_get_line_yrange (text_view, &text_iter, &y, &height);
} while (y < y1);
}
/* Display address */
do
{
gint pos;
guint address;
gtk_text_view_buffer_to_window_coords (text_view,
GTK_TEXT_WINDOW_LEFT,
0,
y,
NULL,
&pos);
address = dma_sparse_iter_get_address (&buf_iter);
if (view->priv->show_line_numbers)
{
g_snprintf (str, sizeof (str),"0x%0*lX", margin_length, (long unsigned int)address);
pango_layout_set_markup (layout, str, -1);
gtk_paint_layout (gtk_widget_get_style (GTK_WIDGET (view)),
win,
gtk_widget_get_state (GTK_WIDGET (view)),
FALSE,
NULL,
GTK_WIDGET (view),
NULL,
text_width + 2,
pos,
layout);
}
/* Display marker */
if ((prev_address != address) && (view->priv->show_line_markers))
{
gint current_marker = dma_sparse_buffer_get_marks (view->priv->buffer, address);
if (current_marker)
{
gint x;
if (view->priv->show_line_numbers)
x = text_width + 4;
else
x = 0;
draw_line_markers (view, current_marker, x, pos);
prev_address = address;
}
}
if (!dma_sparse_iter_forward_lines (&buf_iter, 1)) return;
if (!gtk_text_iter_forward_line (&text_iter)) return;
gtk_text_view_get_line_yrange (text_view, &text_iter, &y, &height);
} while (y < y2);
g_object_unref (G_OBJECT (layout));
}
