GtkWidget *
new_layer(GtkWidget *canvas)
{
gchar label[10];
GtkRequisition req;
gint size;
nlayers++;
buttons = (GtkWidget **)g_realloc(buttons, nlayers * sizeof(GtkWidget *));
plots = (GtkWidget **)g_realloc(plots, nlayers * sizeof(GtkWidget *));
sprintf(label, "%d", nlayers);
buttons[nlayers-1] = gtk_toggle_button_new_with_label(label);
/* gtk_button_set_relief(GTK_BUTTON(buttons[nlayers-1]), GTK_RELIEF_NONE);
*/
gtk_widget_size_request(buttons[nlayers-1], &req);
size = MAX(req.width,req.height);
gtk_widget_set_size_request(buttons[nlayers-1], size, size);
gtk_fixed_put(GTK_FIXED(canvas), buttons[nlayers-1], (nlayers-1)*20, 0);
gtk_widget_show(buttons[nlayers-1]);
g_signal_connect(GTK_OBJECT(buttons[nlayers-1]), "toggled",
(void *) activate_plot, canvas);
plots[nlayers-1] = gtk_plot_new_with_size(NULL, .5, .25);
gtk_widget_show(plots[nlayers-1]);
activate_plot(buttons[nlayers-1],canvas);
return plots[nlayers-1];
}
/* Add an icon grid element and establish its initial visibility. */
void icon_grid_add(IconGrid * ig, GtkWidget * child, gboolean visible)
{
/* Create and initialize a structure representing the child. */
IconGridElement * ige = g_new0(IconGridElement, 1);
ige->ig = ig;
ige->widget = child;
ige->visible = visible;
/* Insert at the tail of the child list. This keeps the graphics in the order they were added. */
if (ig->child_list == NULL)
ig->child_list = ige;
else
{
IconGridElement * ige_cursor;
for (ige_cursor = ig->child_list; ige_cursor->flink != NULL; ige_cursor = ige_cursor->flink) ;
ige_cursor->flink = ige;
}
/* Add the widget to the layout container. */
if (visible)
gtk_widget_show(ige->widget);
gtk_fixed_put(GTK_FIXED(ig->widget), ige->widget, 0, 0);
g_signal_connect(G_OBJECT(child), "size-request", G_CALLBACK(icon_grid_element_size_request), (gpointer) ige);
/* Do a relayout. */
icon_grid_demand_resize(ig);
}
int main (int argc, char *argv[]) {
GtkWidget *window;
GtkWidget *fixed;
GtkWidget *button;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "GtkButton");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 230, 150);
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
button = gtk_button_new_with_label("Click");
gtk_fixed_put(GTK_FIXED(fixed), button, 50, 50);
gtk_widget_set_size_request(button, 80, 35);
// Two signals: clicked and destroy
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(button_clicked), NULL);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void button_init(void)
{
play_button=gtk_button_new_with_label("Play!");
gtk_widget_set_size_request(play_button, button_width, button_height);
gtk_fixed_put(GTK_FIXED(launcher_container), play_button, (launcher_width/2)-(button_width/2), (launcher_height/2)-(button_height/2));
g_signal_connect_swapped(play_button, "clicked", G_CALLBACK(exec_gnome_terminal), NULL);
}
void ProgressBar::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height) {
object->widget = gtk_progress_bar_new();
widget->parent = &parent;
gtk_widget_set_size_request(object->widget, width, height);
gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y);
gtk_widget_show(object->widget);
}
static void
glide_window_fixed_embed_size_allocate (GtkWidget *widget,
GtkAllocation *allocation,
gpointer user_data)
{
GlideWindow *w = (GlideWindow *)user_data;
gint width, height;
if (w->priv->document)
glide_document_get_size (w->priv->document, &width, &height);
else
{
width = DEFAULT_PRESENTATION_WIDTH;
height = DEFAULT_PRESENTATION_HEIGHT;
}
if (allocation->width != w->priv->lfw ||
allocation->height != w->priv->lfh)
{
gtk_fixed_move (GTK_FIXED (widget), w->priv->embed,
(allocation->width-width)/2.0,
(allocation->height-height)/2.0);
w->priv->lfw = allocation->width;
w->priv->lfh = allocation->height;
}
}
GtkWidget*
create_window3 (void)
{
GtkWidget *window3;
GdkPixbuf *window3_icon_pixbuf;
GtkWidget *fixed3;
GtkWidget *label5;
window3 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window3, 236, 122);
gtk_window_set_title (GTK_WINDOW (window3), _("\346\263\250\345\206\214\350\277\233\350\241\214\344\270\255"));
gtk_window_set_resizable (GTK_WINDOW (window3), FALSE);
window3_icon_pixbuf = gdk_pixbuf_new_from_xpm_data((gchar **)connecting_xpm);
if (window3_icon_pixbuf)
{
gtk_window_set_icon (GTK_WINDOW (window3), window3_icon_pixbuf);
gdk_pixbuf_unref (window3_icon_pixbuf);
}
fixed3 = gtk_fixed_new ();
gtk_widget_show (fixed3);
gtk_container_add (GTK_CONTAINER (window3), fixed3);
label5 = gtk_label_new (_("\346\263\250\345\206\214\350\277\233\350\241\214\344\270\255\357\274\214\350\257\267\347\250\215\345\200\231\343\200\202\343\200\202\343\200\202"));
gtk_widget_show (label5);
gtk_fixed_put (GTK_FIXED (fixed3), label5, 24, 40);
gtk_widget_set_size_request (label5, 200, 32);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (window3, window3, "window3");
GLADE_HOOKUP_OBJECT (window3, fixed3, "fixed3");
GLADE_HOOKUP_OBJECT (window3, label5, "label5");
return window3;
}
void make_cancel_button(GtkWidget *fixed_base)
{
GtkWidget *fixed;
GtkWidget *event_box;
GtkWidget *label;
fixed = fixed_base;
label = gtk_label_new(cancel_text);
gtk_widget_set_size_request(label, cancel_label_width, cancel_label_height);
gtk_widget_show(label);
GdkColor white = {0, 65535, 65535, 65535};
GtkRcStyle *rc_style = gtk_rc_style_new ();
rc_style->fg[GTK_STATE_NORMAL] = white;
rc_style->color_flags[GTK_STATE_NORMAL] |= GTK_RC_FG;
gtk_widget_modify_style(label, rc_style);
gtk_rc_style_unref(rc_style);
event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(event_box), label);
gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box), FALSE);
gtk_widget_show(event_box);
g_signal_connect(G_OBJECT(event_box), "enter_notify_event",
G_CALLBACK(cancel_enter), NULL);
g_signal_connect(G_OBJECT(event_box), "leave_notify_event",
G_CALLBACK(cancel_leave), NULL);
g_signal_connect(G_OBJECT(event_box), "button_press_event",
G_CALLBACK(cancel_press), NULL);
gtk_widget_show(event_box);
gtk_fixed_put(GTK_FIXED(fixed), event_box, cancel_label_pos_x, cancel_label_pos_y);
}
int main (int argc, char *argv[]) {
GtkWidget *window;
GtkWidget *fixed;
GtkWidget *button;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 230, 150);
gtk_window_set_title(GTK_WINDOW(window), "enter signal");
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
button = gtk_button_new_with_label("Button");
gtk_widget_set_size_request(button, 80, 35);
gtk_fixed_put(GTK_FIXED(fixed), button, 50, 50);
// call the enter_button() user button when the enter signal occurs
g_signal_connect(G_OBJECT(button), "enter",
G_CALLBACK(enter_button), NULL);
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), G_OBJECT(window));
gtk_widget_show_all(window);
gtk_main();
return 0;
}
GtkWidget* wxPizza::New(long windowStyle,void* owner)
{
GtkWidget* widget = GTK_WIDGET(g_object_new(type(), NULL));
wxPizza* pizza = WX_PIZZA(widget);
pizza->m_owner = owner;
pizza->m_backing_window = NULL;
pizza->m_scroll_x = 0;
pizza->m_scroll_y = 0;
pizza->m_is_scrollable = (windowStyle & (wxHSCROLL | wxVSCROLL)) != 0;
// mask off border styles not useable with wxPizza
pizza->m_border_style = int(windowStyle & BORDER_STYLES);
gtk_fixed_set_has_window(GTK_FIXED(widget), true);
gtk_widget_add_events(widget,
GDK_EXPOSURE_MASK |
GDK_SCROLL_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON2_MOTION_MASK |
GDK_BUTTON3_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
GDK_FOCUS_CHANGE_MASK);
return widget;
}
void Viewport::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height) {
object->widget = gtk_drawing_area_new();
gtk_widget_set_double_buffered(object->widget, false);
gtk_widget_set_size_request(object->widget, width, height);
gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y);
gtk_widget_show(object->widget);
}
static void _GuiWindow_child_resizeCallback (GtkWidget *childWidget, gpointer data) {
GtkAllocation *allocation = (GtkAllocation *) data;
GtkWidget *parentWidget = gtk_widget_get_parent (childWidget);
Thing_cast (GuiThing, child, _GuiObject_getUserData (childWidget));
if (child) {
GuiControl control = NULL;
if (Thing_isa (child, classGuiControl)) {
control = static_cast <GuiControl> (child);
} else if (Thing_isa (child, classGuiMenu)) {
Thing_cast (GuiMenu, menu, child);
control = menu -> d_cascadeButton;
}
if (control) {
/*
* Move and resize.
*/
trace (U"moving child of class ", Thing_className (control));
int left = control -> d_left, right = control -> d_right, top = control -> d_top, bottom = control -> d_bottom;
if (left < 0) left += allocation -> width; // this replicates structGuiControl :: v_positionInForm ()
if (right <= 0) right += allocation -> width;
if (top < 0) top += allocation -> height;
if (bottom <= 0) bottom += allocation -> height;
trace (U"moving child to (", left, U",", top, U")");
gtk_fixed_move (GTK_FIXED (parentWidget), GTK_WIDGET (childWidget), left, top);
gtk_widget_set_size_request (GTK_WIDGET (childWidget), right - left, bottom - top);
trace (U"moved child of class ", Thing_className (control));
}
}
}
void VLGbutton::moveTo(int nx,int ny) {
if (parent) {
gtk_fixed_move (GTK_FIXED (((VLGform*)parent)->fixed), widget, nx, ny);
x=nx;
y=ny;
}
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkLabelPeer_setNativeBounds
(JNIEnv *env, jobject obj, jint x, jint y, jint width, jint height)
{
GtkWidget *widget;
void *ptr;
ptr = NSA_GET_PTR (env, obj);
gdk_threads_enter ();
widget = GTK_WIDGET (ptr);
/* We assume that -1 is a width or height and not a request for the
widget's natural size. */
width = width < 0 ? 0 : width;
height = height < 0 ? 0 : height;
if (!(width == 0 && height == 0))
{
/* Set the event box's size request... */
gtk_widget_set_size_request (widget, width, height);
/* ...and the label's size request. */
gtk_widget_set_size_request (gtk_bin_get_child (GTK_BIN (widget)),
width, height);
if (widget->parent != NULL)
gtk_fixed_move (GTK_FIXED (widget->parent), widget, x, y);
}
gdk_threads_leave ();
}
int main(int argc, char **argv)
{
GtkWidget *window;
GtkWidget *fixed;
GtkWidget *button;
gint i;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Fixed Container");
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
gtk_widget_show(fixed);
for(i=1; i<=3; i++)
{
button = gtk_button_new_with_label("Press me");
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(move_button), fixed);
gtk_fixed_put(GTK_FIXED(fixed), button, i*50, i*50);
gtk_widget_show(button);
}
gtk_widget_show(window);
gtk_main();
return 0;
}
/* This callback function moves the button to a new position
* in the Fixed container. */
void move_button( GtkWidget *widget,
GtkWidget *fixed )
{
x = (x+30)%300;
y = (y+50)%300;
gtk_fixed_move( GTK_FIXED(fixed), widget, x, y);
}
GtkWidget* wxPizza::New(long windowStyle)
{
GtkWidget* widget = GTK_WIDGET(g_object_new(type(), NULL));
wxPizza* pizza = WX_PIZZA(widget);
pizza->m_scroll_x = 0;
pizza->m_scroll_y = 0;
pizza->m_is_scrollable = (windowStyle & (wxHSCROLL | wxVSCROLL)) != 0;
// mask off border styles not useable with wxPizza
pizza->m_border_style = int(windowStyle & BORDER_STYLES);
#if GTK_CHECK_VERSION(3,0,0) || defined(GTK_DISABLE_DEPRECATED)
gtk_widget_set_has_window(widget, true);
#else
gtk_fixed_set_has_window(GTK_FIXED(widget), true);
#endif
gtk_widget_add_events(widget,
GDK_EXPOSURE_MASK |
GDK_SCROLL_MASK |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON2_MOTION_MASK |
GDK_BUTTON3_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK |
GDK_FOCUS_CHANGE_MASK);
return widget;
}
void CalendarDatePrivate::initMonthView() {
GtkWidget* swipebox = NULL;
int row = 0;
int col = 0;
int rowCount = 3;
int colCount = 4;
GDateTime* nowDate = g_date_time_new_now_local();
int selectedYear = m_selectedYear;
int cellWidth = MAIN_BOX_DEFAULT_WIDTH / colCount;
int cellHeight = MAIN_BOX_DEFAULT_WIDTH / rowCount;
m_swipeBox[VIEWTYPE_MONTH] = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
swipebox = m_swipeBox[VIEWTYPE_MONTH];
gtk_fixed_put(GTK_FIXED(m_mainBox), GTK_WIDGET(m_swipeBox[VIEWTYPE_MONTH]), 0, 0);
gtk_widget_set_name(GTK_WIDGET(swipebox), "calendar-table");
GDateTime* selectedDate = g_date_time_new_local(m_selectedYear, m_selectedMonth, m_selectedDayOfMonth, 1, 1, 1);
gchar* dateLabelText = g_date_time_format(selectedDate, C_("calendar heading", "%Y"));
gtk_button_set_label(GTK_BUTTON(m_viewTypeSwitch), dateLabelText);
g_date_time_unref(selectedDate);
g_free(dateLabelText);
for (row = 0; row < rowCount; ++row) {
GtkWidget* monthlayout = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
for (col = 0; col < colCount; ++col) {
int index = row * colCount + col;
m_monthItem[index] = new CalendarItem(ITEMTYPE_MONTH, index + 1);
m_monthItem[index]->setOnClickedListener(this);
m_monthItem[index]->setSize(cellWidth, cellHeight);
m_monthItem[index]->setParent(GTK_WIDGET(monthlayout));
}
gtk_box_pack_start(GTK_BOX(swipebox), GTK_WIDGET(monthlayout), TRUE, TRUE, 0);
}
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_gtkWidgetSetParent
(JNIEnv *env, jobject obj, jobject parent)
{
void *ptr;
void *parent_ptr;
GtkWidget *widget;
GtkWidget *parent_widget;
gdk_threads_enter ();
ptr = gtkpeer_get_widget (env, obj);
parent_ptr = gtkpeer_get_widget (env, parent);
widget = GTK_WIDGET (ptr);
parent_widget = get_widget(GTK_WIDGET (parent_ptr));
if (widget->parent == NULL)
{
if (GTK_IS_WINDOW (parent_widget))
{
GList *children = gtk_container_get_children
(GTK_CONTAINER (parent_widget));
if (GTK_IS_MENU_BAR (children->data))
gtk_fixed_put (GTK_FIXED (children->next->data), widget, 0, 0);
else
gtk_fixed_put (GTK_FIXED (children->data), widget, 0, 0);
}
else
if (GTK_IS_SCROLLED_WINDOW (parent_widget))
{
gtk_scrolled_window_add_with_viewport
(GTK_SCROLLED_WINDOW (parent_widget), widget);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (widget->parent),
GTK_SHADOW_NONE);
}
else
{
if (widget->parent == NULL)
gtk_fixed_put (GTK_FIXED (parent_widget), widget, 0, 0);
}
}
gdk_threads_leave ();
}
void *GtkMain(void * argument)
{
printf("%s:%d\n", __func__, __LINE__);
int argc = 0;
char**argv = NULL;
unsigned char haveUrl = 0;
int argCount = 0;
gtk_init (&argc, &argv);
if (!g_thread_supported ())
g_thread_init (NULL);
GtkWidget* fixed = gtk_fixed_new();
//screen_changed(fixed, NULL, NULL);
g_vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (g_vbox), create_toolbar (), FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (g_vbox), GTK_WIDGET (create_browser ()), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (g_vbox), create_statusbar (), FALSE, FALSE, 0);
g_window = create_window ();
gtk_fixed_put(GTK_FIXED(fixed), g_vbox, 0, 0);
gtk_widget_set_size_request(g_vbox, g_framebuffer_width, g_framebuffer_height);
GtkWidget* statusLabel = gtk_label_new ("Status");
gtk_fixed_put(GTK_FIXED(fixed), statusLabel, g_framebuffer_width - 200, 0);
gtk_widget_set_size_request(statusLabel, 200, 100);
gtk_container_add (GTK_CONTAINER (g_window), fixed);
webkit_web_view_load_uri (g_web_view, g_url);
gtk_widget_grab_focus (GTK_WIDGET (g_web_view));
gtk_widget_show_all (g_window);
toogleMode();
g_default_scale = g_framebuffer_width / 1280.0f;
handleZoomLock(0);
g_Callback(1);
gtk_main ();
return NULL;
}
static void
cpaf_fixed_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkFixed *fixed;
GtkFixedChild *child;
GtkAllocation child_allocation;
GtkRequisition child_requisition;
GList *children;
guint16 border_width;
fixed = GTK_FIXED (widget);
widget->allocation = *allocation;
if (!GTK_WIDGET_NO_WINDOW (widget))
{
if (GTK_WIDGET_REALIZED (widget))
gdk_window_move_resize (widget->window,
allocation->x,
allocation->y,
allocation->width,
allocation->height);
}
border_width = GTK_CONTAINER (fixed)->border_width;
children = fixed->children;
while (children)
{
child = children->data;
children = children->next;
if (GTK_WIDGET_VISIBLE (child->widget))
{
gtk_widget_get_child_requisition (child->widget, &child_requisition);
child_allocation.x = child->x + border_width;
child_allocation.y = child->y + border_width;
child_allocation.height = child->widget->allocation.height;
child_allocation.width = child->widget->allocation.width;
/* Ensure that the allocation is not smaller than the requisition (CHECKME:) */
if (child_allocation.height < child_requisition.height)
child_allocation.height = child_requisition.height;
if (child_allocation.width < child_requisition.width)
child_allocation.width = child_requisition.width;
if (GTK_WIDGET_NO_WINDOW (widget))
{
child_allocation.x += widget->allocation.x;
child_allocation.y += widget->allocation.y;
}
gtk_widget_size_allocate (child->widget, &child_allocation);
}
}
}
void add_enabled_joints(cartesianMover* cm, GtkWidget *vbox)
{
GtkWidget *check= gtk_check_button_new_with_mnemonic ("test");
gtk_fixed_put (GTK_FIXED(vbox), check, 10, 0);
gtk_widget_set_size_request (check, 80, 50);
gtk_toggle_button_set_active((GtkToggleButton*) check, true);
//g_signal_connect (check, "clicked", G_CALLBACK (check_pressed),ENA[n]);
}
void Button::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height, const char *text) {
object->widget = gtk_button_new_with_label(text);
gtk_widget_set_size_request(object->widget, width, height);
g_signal_connect_swapped(G_OBJECT(object->widget), "clicked", G_CALLBACK(Button_tick), (gpointer)this);
if(parent.window->defaultFont) setFont(*parent.window->defaultFont);
gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y);
gtk_widget_show(object->widget);
}
static void activate(GtkApplication* app,
gpointer user_data)
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *button_rs;
GtkWidget *button_box;
GtkWidget *draw_area;
GtkWidget *fixed_container;
window = gtk_application_window_new(app);
gtk_window_set_title(GTK_WINDOW(window), "Five Son Chess");
gtk_window_set_default_size(GTK_WINDOW(window), 900, 900);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
fixed_container = gtk_fixed_new();
// Draw Area
draw_area = gtk_drawing_area_new();
gtk_widget_set_size_request(draw_area, CanvasWidth, CanvasWidth);
g_signal_connect(draw_area, "draw", G_CALLBACK(draw_cb), NULL);
g_signal_connect(draw_area, "configure-event", G_CALLBACK(configure_event_cb), NULL);
gtk_widget_add_events(draw_area, GDK_BUTTON_PRESS_MASK);
g_signal_connect(draw_area, "button_press_event", G_CALLBACK(PutPiece), draw_area);
gtk_fixed_put(GTK_FIXED(fixed_container), draw_area, 0, 0);
// Buttons
button_box = gtk_button_box_new(GTK_ORIENTATION_VERTICAL);
gtk_fixed_put(GTK_FIXED(fixed_container), button_box, CanvasWidth, 0);
button = gtk_button_new_with_label("从头再来");
g_signal_connect(button, "clicked", G_CALLBACK(init_cb), draw_area);
button_rs = gtk_button_new_with_label("随机开局");
g_signal_connect(button_rs, "clicked", G_CALLBACK(init_rs_cb), draw_area);
gtk_container_add(GTK_CONTAINER(button_box), button);
gtk_container_add(GTK_CONTAINER(button_box), button_rs);
gtk_container_add(GTK_CONTAINER(window), fixed_container);
gtk_widget_show_all(window);
// Game starts here!
InitializeGame();
}
/**
Muestra la ventana para la selección de especies
@param numEspecies, nº de especies
@param especies, vector con los nombres de las especies
@param especieSelec, nº de la especie seleccionada (argumento de salida)
*/
bool ventanaSeleccionEspecie(const int numEspecies, const vector<string> &especies, gint &especieSelec) {
GtkWidget *ventanaEspecies = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget *listaEspecies = gtk_vbox_new(TRUE, 0);
GtkWidget *fixed = gtk_fixed_new();
struct datosGestorCancelarEspecies datos;
gtk_window_set_title(GTK_WINDOW(ventanaEspecies), "Species selection");
gtk_window_set_position(GTK_WINDOW(ventanaEspecies), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(ventanaEspecies), 150, 150);
listaEspecies = gtk_combo_box_new_text();
for(int i = 0; i < numEspecies; i++) {
gtk_combo_box_append_text(GTK_COMBO_BOX(listaEspecies), especies[i].c_str());
}
gtk_combo_box_set_active(GTK_COMBO_BOX(listaEspecies), 0); especieSelec = 0;
GtkWidget *label = gtk_label_new("Select an species:");
gtk_fixed_put(GTK_FIXED(fixed), label, 10, 10);
gtk_fixed_put(GTK_FIXED(fixed), listaEspecies, 40, 50);
gtk_container_add(GTK_CONTAINER(ventanaEspecies), fixed);
GtkWidget *botonAceptar = gtk_button_new_with_label( "Accept" );
gtk_fixed_put(GTK_FIXED(fixed), botonAceptar, 10, 110);
GtkWidget *botonCancelar = gtk_button_new_with_label( "Cancel" );
gtk_fixed_put(GTK_FIXED(fixed), botonCancelar, 80, 110);
datos.ventanaEspecies = ventanaEspecies; datos.cancelar = false;
g_signal_connect_swapped(G_OBJECT(ventanaEspecies), "destroy", G_CALLBACK(gtk_main_quit), G_OBJECT(ventanaEspecies));
g_signal_connect(G_OBJECT(listaEspecies), "changed", G_CALLBACK(listaEspeciesSelected), (gpointer) &especieSelec);
g_signal_connect( G_OBJECT( botonAceptar ), "clicked", G_CALLBACK( gestorAceptarEspecies ), ( gpointer ) ventanaEspecies );
g_signal_connect( G_OBJECT( botonCancelar ), "clicked", G_CALLBACK( gestorCancelarEspecies ), ( gpointer ) &datos );
gtk_widget_show_all(ventanaEspecies);
gtk_main();
if(true == datos.cancelar) {
return(false);
}
return(true);
}
void graphicsInit(GtkWidget *frame, field_t *field)
{
GtkWidget *darea;
darea = gtk_drawing_area_new();
gtk_fixed_put(GTK_FIXED(frame), darea, 0, 0);
gtk_widget_set_size_request(darea, field->size.x * pixelConst + 10 + 100, field->size.y * pixelConst + 10);
g_signal_connect(G_OBJECT(darea), "draw", G_CALLBACK(on_draw_event), field);
g_timeout_add(10, (GSourceFunc) screenUpdate, darea); //condition to stop
}
void gui_main::LoadServoControls(GtkWidget * frame){
for (int i = 1; i < srvQuantity + 1; i++){
int xOffset = (i-1) / 6;
PwmViews[i-1] = new pwm_gtk_control(to_string(i).c_str(), ServosModel->ServoParams[(i - 1) * 3 + 1], ServosModel->ServoParams[(i - 1) * 3 + 2], ServosModel->ServoParams[(i - 1) * 3]);
PwmViews[i-1]->SetServo(ServosModel->Servos[i-1]);
gtk_fixed_put(GTK_FIXED (_pwmControlPage), PwmViews[i-1]->get_main(), xOffset * 400, (i-1) * 75 - xOffset * 450);
}
// add all pwm controls
AllOffButton = gtk_button_new_with_label("All OFF");
g_signal_connect (AllOffButton, "clicked", G_CALLBACK (gui_main::btnAllOffClick), this);
gtk_widget_set_usize(AllOffButton, 100, 40);
gtk_fixed_put(GTK_FIXED (_pwmControlPage), AllOffButton, 785, 20);
AllOnButton = gtk_button_new_with_label("All ON");
g_signal_connect (AllOnButton, "clicked", G_CALLBACK (gui_main::btnAllOnClick), this);
gtk_widget_set_usize(AllOnButton, 100, 40);
gtk_fixed_put(GTK_FIXED (_pwmControlPage), AllOnButton, 785, 65);
}
int main(int argc, char** argv) {
GtkWidget *label;
GtkWidget *window;
GtkWidget *frame;
GtkWidget *plus;
GtkWidget *minus;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 250, 180);
gtk_window_set_title(GTK_WINDOW(window), "+-");
frame = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), frame);
plus = gtk_button_new_with_label("+");
gtk_widget_set_size_request(plus, 80, 35);
gtk_fixed_put(GTK_FIXED(frame), plus, 50, 20);
minus = gtk_button_new_with_label("-");
gtk_widget_set_size_request(minus, 80, 35);
gtk_fixed_put(GTK_FIXED(frame), minus, 50, 80);
label = gtk_label_new("0");
gtk_fixed_put(GTK_FIXED(frame), label, 190, 58);
gtk_widget_show_all(window);
g_signal_connect(window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect(plus, "clicked",
G_CALLBACK(increase), label);
g_signal_connect(minus, "clicked",
G_CALLBACK(decrease), label);
gtk_main();
return 0;
}
int main(int argc, char *argv[])
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 700, 580);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
GtkWidget* fixed_container = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed_container);
GtkWidget *button = gtk_button_new_with_label("Get");
gtk_fixed_put(GTK_FIXED(fixed_container), button, 655, 10);
GtkWidget *entry1 = gtk_entry_new();
gtk_fixed_put(GTK_FIXED(fixed_container), entry1, 10, 10);
gtk_widget_set_size_request(entry1, 645, 15);
gtk_entry_set_text(GTK_ENTRY(entry1),"Paul Walker");
GtkWidget *text1 = gtk_text_view_new();
gtk_fixed_put(GTK_FIXED(fixed_container), text1, 10, 50);
//gtk_container_add(GTK_CONTAINER(scrolledwindow), text1);
gtk_widget_set_size_request(text1, 675, 520);
gtk_text_view_set_wrap_mode(text1,GTK_WRAP_WORD_CHAR);
void process()
{
getwiki(gtk_entry_get_text(GTK_ENTRY(entry1)));
char *textout;
GtkTextIter start, end;
GtkTextBuffer *buffer=gtk_text_view_get_buffer (GTK_TEXT_VIEW(text1));
textout = parse(chunk.memory);
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_delete(buffer,&start,&end);
gtk_text_buffer_insert(buffer,&end,textout,strlen(textout));
gtk_text_view_set_buffer(text1,buffer);
}
void load_gauge(GtkWidget *dash, xmlNode *node)
{
xmlNode *cur_node = NULL;
GtkWidget *gauge = NULL;
gchar * filename = NULL;
gint width = 0;
gint height = 0;
gint x_offset = 0;
gint y_offset = 0;
gchar *xml_name = NULL;
gchar *datasource = NULL;
if (!node->children)
{
printf("ERROR, load_gauge, xml node is empty!!\n");
return;
}
cur_node = node->children;
while (cur_node->next) { if (cur_node->type == XML_ELEMENT_NODE)
{
if (g_strcasecmp((gchar *)cur_node->name,"width") == 0)
generic_xml_gint_import(cur_node,&width);
if (g_strcasecmp((gchar *)cur_node->name,"height") == 0)
generic_xml_gint_import(cur_node,&height);
if (g_strcasecmp((gchar *)cur_node->name,"x_offset") == 0)
generic_xml_gint_import(cur_node,&x_offset);
if (g_strcasecmp((gchar *)cur_node->name,"y_offset") == 0)
generic_xml_gint_import(cur_node,&y_offset);
if (g_strcasecmp((gchar *)cur_node->name,"gauge_xml_name") == 0)
generic_xml_gchar_import(cur_node,&xml_name);
if (g_strcasecmp((gchar *)cur_node->name,"datasource") == 0)
generic_xml_gchar_import(cur_node,&datasource);
}
cur_node = cur_node->next;
}
if (xml_name && datasource)
{
gauge = mtx_gauge_face_new();
gtk_fixed_put(GTK_FIXED(dash),gauge,x_offset,y_offset);
xml_name = g_strdelimit(xml_name,"\\",'/');
filename = get_file(g_build_filename(PSEP,GAUGES_DATA_DIR,xml_name,NULL),NULL);
mtx_gauge_face_import_xml(MTX_GAUGE_FACE(gauge),filename);
gtk_widget_set_usize(gauge,width,height);
g_free(filename);
OBJ_SET_FULL((gauge),"datasource",g_strdup(datasource),g_free);
/* Cheat to get property window created... */
create_preview_list(NULL,NULL);
update_properties(gauge,GAUGE_ADD);
g_free(xml_name);
g_free(datasource);
gtk_widget_show_all(dash);
}
}
