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_usize(buttons[nlayers-1], size, size);
gtk_fixed_put(GTK_FIXED(canvas), buttons[nlayers-1], (nlayers-1)*20, 0);
gtk_widget_show(buttons[nlayers-1]);
plots[nlayers-1] = gtk_plot_new_with_size(NULL, .5, .25);
gtk_widget_show(plots[nlayers-1]);
return plots[nlayers-1];
}
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;
}
void fx_close_initialize(FxClose *fxclose)
{
GSList *group;
GtkWidget *okBtn , *cancelBtn , *label;
GdkPixbuf *pb;
GtkBox *vbox , *action_area;
GtkFixed *fixed;
fxclose->dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(fxclose->dialog) , _("Notification"));
pb = gdk_pixbuf_new_from_file_at_size(SKIN_DIR"online.svg" , 22 , 22 , NULL);
gtk_window_set_icon(GTK_WINDOW(fxclose->dialog) , pb);
g_object_unref(pb);
gtk_widget_set_usize(fxclose->dialog , 280 , 180);
gtk_window_set_resizable(GTK_WINDOW(fxclose->dialog) , FALSE);
vbox = GTK_BOX(GTK_DIALOG(fxclose->dialog)->vbox);
action_area = GTK_BOX(GTK_DIALOG(fxclose->dialog)->action_area);
fixed = GTK_FIXED(gtk_fixed_new());
gtk_box_pack_start_defaults(vbox , GTK_WIDGET(fixed));
label = gtk_label_new(_("Are you sure you want to exit OpenFetion?"));
gtk_fixed_put(fixed , label , 20 , 20);
fxclose->closeBtn = gtk_radio_button_new_with_label(NULL , _("Exit OpenFetion"));
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(fxclose->closeBtn));
fxclose->iconBtn = gtk_radio_button_new_with_label(group , _("Minimize to Tray"));
fxclose->notalert = gtk_check_button_new_with_label(_("Don't notify again"));
gtk_fixed_put(fixed , fxclose->closeBtn , 40 , 50);
gtk_fixed_put(fixed , fxclose->iconBtn , 40 , 70);
gtk_fixed_put(fixed , fxclose->notalert , 40 , 100);
okBtn = gtk_button_new_with_label(_("OK"));
g_signal_connect(okBtn , "clicked" , G_CALLBACK(fx_close_on_ok_clicked) , fxclose->dialog);
cancelBtn = gtk_button_new_with_label(_("Cancel"));
g_signal_connect(cancelBtn , "clicked" , G_CALLBACK(fx_close_on_cancel_clicked) , fxclose->dialog);
gtk_box_pack_start_defaults(action_area , okBtn);
gtk_box_pack_start_defaults(action_area , cancelBtn);
GTK_WIDGET_SET_FLAGS(okBtn, GTK_CAN_FOCUS);
gtk_widget_grab_focus(okBtn);
gtk_widget_show_all(fxclose->dialog);
}
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();
}
void iupgtkBaseAddToParent(Ihandle* ih)
{
GtkFixed* fixed = gtkGetFixedParent(ih);
GtkWidget* widget = (GtkWidget*)iupAttribGet(ih, "_IUP_EXTRAPARENT");
if (!widget) widget = ih->handle;
gtk_fixed_put(fixed, widget, 0, 0);
}
/*
* CBoardDevice::Init()
*
* Initializes the device
*
* Returns: True if the initializing was successful and false if it failed.
*/
bool CBoardDevice::Init(GtkFixed *board_area, CBoardDeviceGroup *device_group)
{
this->device_group = device_group;
// Load the bitmap
GdkPixbuf *bg_pixbuf = gdk_pixbuf_new_from_stream(CFile(image_file.c_str()).get_input_stream(), NULL, NULL);
if(bg_pixbuf == NULL)
return false;
bitmap_x = bitmap_y = 0;
width = gdk_pixbuf_get_width(bg_pixbuf);
height = gdk_pixbuf_get_height(bg_pixbuf);
// Check if the type is LED, PUSH or TOGGLE
if(!strcmp(type.c_str(), "LED") ||
!strcmp(type.c_str(), "PUSH") ||
!strcmp(type.c_str(), "TOGGLE"))
{
// Set the appropriate width and height of the bitmap
width = width / 2;
// Check if PUSH because pushbuttons have the value 1 if they are up
if(!strcmp(type.c_str(), "PUSH"))
bitmap_x = 1;
}
// Check if the type is SSLED
else if(!strcmp(type.c_str(), "SSLED"))
{
// Set the appropriate width and height of the bitmap
width = width / 8;
height = height / 16;
}
GtkWidget *bg_viewport = gtk_viewport_new(NULL, NULL);
gtk_widget_set_events(bg_viewport, GDK_BUTTON_RELEASE_MASK);
g_signal_connect(G_OBJECT(bg_viewport), "button-press-event", G_CALLBACK(device_button_pressed), this);
g_signal_connect(G_OBJECT(bg_viewport), "button-release-event", G_CALLBACK(device_button_released), this);
gtk_widget_show(bg_viewport);
GtkWidget *bg_image = gtk_image_new_from_pixbuf(bg_pixbuf);
gtk_widget_show(bg_image);
gtk_container_add((GtkContainer*)bg_viewport, bg_image);
gtk_viewport_set_shadow_type((GtkViewport*)bg_viewport, GTK_SHADOW_NONE);
gtk_widget_set_size_request(bg_viewport, width, height);
gtk_adjustment_set_upper(gtk_viewport_get_hadjustment((GtkViewport*)bg_viewport), width);
gtk_adjustment_set_upper(gtk_viewport_get_vadjustment((GtkViewport*)bg_viewport), height);
gtk_fixed_put(board_area, bg_viewport, coords.x, coords.y);
g_object_unref(bg_pixbuf);
viewport = (GtkViewport*)bg_viewport;
ShowCorrectImage();
return true;
}
/**
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 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);
}
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
}
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);
}
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;
}
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);
}
}
void HorizontalSlider::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height, unsigned length) {
object->position = 0;
length += (length == 0);
object->widget = gtk_hscale_new_with_range(0, length - 1, 1);
gtk_scale_set_draw_value(GTK_SCALE(object->widget), false);
gtk_widget_set_size_request(object->widget, width, height);
g_signal_connect_swapped(G_OBJECT(object->widget), "value-changed", G_CALLBACK(HorizontalSlider_change), (gpointer)this);
gtk_fixed_put(GTK_FIXED(parent.object->formContainer), object->widget, x, y);
gtk_widget_show(object->widget);
}
int main (int argc, char *argv[]) {
GtkWidget *window;
GtkWidget *fixed;
GtkWidget *button1;
GtkWidget *button2;
GtkWidget *button3;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "GtkFixed");
gtk_window_set_default_size(GTK_WINDOW(window), 290, 200);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
// creates GtkFixed container widget
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
button1 = gtk_button_new_with_label("Button");
// button placement with gtk_fixed_put (location is absolute)
gtk_fixed_put(GTK_FIXED(fixed), button1, 150, 50);
gtk_widget_set_size_request(button1, 80, 35);
button2 = gtk_button_new_with_label("Button");
gtk_fixed_put(GTK_FIXED(fixed), button2, 15, 15);
gtk_widget_set_size_request(button2, 80, 35);
button3 = gtk_button_new_with_label("Button");
gtk_fixed_put(GTK_FIXED(fixed), button3, 100, 100);
gtk_widget_set_size_request(button3, 80, 35);
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void devolucao_confirmacao (GtkWidget *wid, GtkWidget *win)
{
if (devolucao_codigo == NULL || devolucao_cpf == NULL || strcmp (devolucao_codigo, "\0") == 0 || strcmp (devolucao_cpf, "\0") == 0)
{
dialog_err_entry_vazio(wid, win);
}
else
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *fixed;
GtkWidget *label;
GtkWidget *button;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (window, FALSE);
gtk_window_set_title (GTK_WINDOW (window), "Locação de filmes");
gtk_widget_set_size_request (GTK_WIDGET (window), 350, 210);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new ("Nome do cliente: %s\nCPF do cliente: %s\nNome do filme: %s\nCódigo do filme: %s\nDevolução: %s\n\nConfirmar devolução?");
gtk_container_add (GTK_CONTAINER (vbox), label);
fixed = gtk_fixed_new ();
gtk_container_add (GTK_CONTAINER (vbox), fixed);
button = gtk_button_new_with_label ("Voltar");
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (voltar_locacao), (gpointer) window);
gtk_fixed_put (GTK_FIXED (fixed), button, 10, 15);
gtk_widget_set_size_request (button, 100, 35);
button = gtk_button_new_with_label ("Confirmar");
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (voltar_locacao), (gpointer) window);
gtk_fixed_put (GTK_FIXED (fixed), button, 219, 15);
gtk_widget_set_size_request (button, 100, 35);
gtk_widget_show_all (window);
}
}
int main( int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *fixed;
GtkWidget *combo;
GtkWidget *label;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "GtkCombo");
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();
combo = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Ubuntu");
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Mandriva");
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Fedora");
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Mint");
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Gentoo");
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Debian");
gtk_fixed_put(GTK_FIXED(fixed), combo, 50, 50);
gtk_container_add(GTK_CONTAINER(window), fixed);
label = gtk_label_new("-");
gtk_fixed_put(GTK_FIXED(fixed), label, 50, 110);
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), G_OBJECT(window));
g_signal_connect(G_OBJECT(combo), "changed",
G_CALLBACK(combo_selected), (gpointer) label);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
int main (int argc, char ** argv)
{
GtkWidget *window;
GtkWidget *cpu;
GtkWidget *fixed;
GtkWidget *scale;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "CPU widget");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(window), 200, 180);
//gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
cpu = gtk_cpu_new();
gtk_fixed_put(GTK_FIXED(fixed), cpu, 30, 40);
scale = gtk_vscale_new_with_range(0.0, 100.0, 1.0);
gtk_range_set_inverted(GTK_RANGE(scale), TRUE);
gtk_scale_set_value_pos(GTK_SCALE(scale), GTK_POS_TOP);
gtk_widget_set_size_request(scale, 50, 120);
gtk_fixed_put(GTK_FIXED(fixed), scale, 130, 20);
g_signal_connect(G_OBJECT(scale), "value_changed", G_CALLBACK(set_value), (gpointer) cpu);
gtk_widget_show(cpu);
gtk_widget_show(fixed);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void WindowApp::viewSummary(GtkWidget *widget, WindowApp *theApp){
gtk_widget_destroy(theApp->admin_window);
gtk_widget_destroy(theApp->appFrame);
theApp->appFrame = gtk_fixed_new();
theApp->admin_combo = gtk_combo_box_text_new();
theApp->admin_cancel = gtk_button_new_with_label("Cancel");
gtk_widget_set_size_request(theApp->admin_cancel, 80, 35);
gtk_fixed_put(GTK_FIXED(theApp->appFrame), theApp->admin_cancel , 100, 150);
gtk_fixed_put(GTK_FIXED(theApp->appFrame), theApp->admin_combo, 50, 50);
theApp->summary_combo = gtk_combo_box_text_new();
gtk_fixed_put(GTK_FIXED(theApp->appFrame), theApp->summary_combo, 50, 100);
gtk_container_add(GTK_CONTAINER(theApp->window), theApp->appFrame);
gtk_widget_show_all(theApp->window);
char text[800];
string courses[800];
ifstream inFile("courses.txt", ios::in);
if (!inFile) {
cout<<"Could not open file"<<endl;
exit(1);
}
while (!inFile.eof()) {
inFile.getline(text, 800);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(theApp->admin_combo), text);
}
g_signal_connect(theApp->admin_cancel, "clicked", G_CALLBACK (Control::submitToMain), theApp);
g_signal_connect(GTK_COMBO_BOX(theApp->admin_combo), "changed", G_CALLBACK (WindowApp::updateCombo), theApp);
if(theApp->allCourses)
updateCombo(widget,theApp);
}
int main( int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *fixed;
GtkWidget *button;
GtkWidget *check;
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, 150);
gtk_window_set_title(GTK_WINDOW(window), "Disconnect");
fixed = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
button = gtk_button_new_with_label("Click");
gtk_widget_set_size_request(button, 80, 30);
gtk_fixed_put(GTK_FIXED(fixed), button, 30, 50);
check = gtk_check_button_new_with_label("Connect");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
gtk_fixed_put(GTK_FIXED(fixed), check, 130, 50);
handler_id = g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(button_clicked), NULL);
g_signal_connect(G_OBJECT(check), "clicked",
G_CALLBACK(toogle_signal), (gpointer) button);
g_signal_connect_swapped(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
int main(int argc, char** argv)
{
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
fixed = gtk_fixed_new();
gtk_widget_set_name(fixed, "fixed");
fixed_on_box = gtk_fixed_new();
gtk_widget_set_size_request(window, 800, 480);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), "pressed");
gtk_widget_add_events(window, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK);
g_signal_connect(G_OBJECT(window), "event", G_CALLBACK(on_window_event), NULL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
bg = gtk_image_new_from_file("background.png");
gtk_widget_set_size_request(bg, 800, 480);
gtk_fixed_put(GTK_FIXED(fixed), bg, 0, 0);
//gtk_container_add(GTK_CONTAINER(fixed), fixed_on_box);
pic1 = gtk_image_new_from_file("movie_logo.png");
gtk_widget_set_name(pic1, "pic1");
gtk_widget_set_size_request(pic1, 150, 150);
pic2 = gtk_image_new_from_file("button_bg.png");
gtk_widget_set_size_request(pic2, 50, 50);
//g_signal_connect(G_OBJECT(window), "button-release-event", G_CALLBACK(on_pic2_released), NULL);
gtk_fixed_put(GTK_FIXED(fixed), pic1, 10, 10);
//gtk_fixed_put(GTK_FIXED(fixed_on_box), pic1, 10, 10);
//gtk_fixed_put(GTK_FIXED(fixed_on_box), pic2, 60, 60);
gtk_container_add(GTK_CONTAINER(window), fixed);
//g_timeout_add(10, time_out_cb, NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void TextBox::create(Window &parent, unsigned x, unsigned y, unsigned width, unsigned height, const string &text) {
object->widget = gtk_entry_new();
widget->parent = &parent;
gtk_entry_set_text(GTK_ENTRY(object->widget), text);
gtk_widget_set_size_request(object->widget, width, height);
g_signal_connect_swapped(G_OBJECT(object->widget), "activate", G_CALLBACK(TextBox_activate), (gpointer)this);
g_signal_connect_swapped(G_OBJECT(object->widget), "changed", G_CALLBACK(TextBox_change), (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);
}
void layout( GtkFixed* f )
{
gtk_fixed_put( f, GTK_WIDGET(powerswitch), 35, 51 );
gtk_fixed_put( f, powerled, 39, 43 );
gtk_fixed_put( f, keyboard->widget, 129, 111 );
gtk_fixed_put( f, tuneKnob->widget, 77, 50 );
layoutPerformanceSection(f);
layoutTransposeHoldSection(f);
layoutArpeggioSection(f);
layoutLfoSection(f);
layoutDcoSection(f);
layoutHpfSection(f);
layoutVcfSection(f);
layoutVcaSection(f);
layoutEnvSection(f);
layoutChorusSection(f);
layoutPatchSection(f);
}
///////////////////////////////////////////
// INITIALIZATION AND MEASURE GENERATION //
///////////////////////////////////////////
static void generateINIT(GTKwrapper* state){
/* Initialize GPIB button */
state->initBUTTON = gtk_button_new_with_label("Initialize GPIB");
g_signal_connect(state->initBUTTON,"clicked", G_CALLBACK(INITIALIZE_GPIB),state);
gtk_fixed_put(GTK_FIXED(state->fixed), state->initBUTTON, X1, Y1);
gtk_widget_set_size_request(state->initBUTTON, BWIDTH, BHEIGHT);
/* GPIB address selector */
GtkWidget* adj = (GtkWidget*)gtk_adjustment_new(0,1,30,1,1,0);
state->gpibBUTTON = gtk_spin_button_new(GTK_ADJUSTMENT(adj),1,2);
g_signal_connect(state->gpibBUTTON,"value-changed", G_CALLBACK(SETGPIB), NULL);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON (state->gpibBUTTON),0);
gtk_fixed_put(GTK_FIXED(state->fixed), state->gpibBUTTON, X2, Y1);
gtk_widget_set_size_request(state->gpibBUTTON, 100 , BHEIGHT);
/* Measure Button */
state->measBUTTON = gtk_button_new_with_label("Measure");
gtk_fixed_put(GTK_FIXED(state->fixed), state->measBUTTON, X4, Y1);
g_signal_connect(state->measBUTTON,"clicked", G_CALLBACK(MEASURE),state);
gtk_widget_set_size_request(state->measBUTTON, BWIDTH, BHEIGHT);
}
int main( int argc,
char *argv[] )
{
/* GtkWidget is the storage type for widgets */
GtkWidget *window;
GtkWidget *fixed;
GtkWidget *button;
gint i;
/* Initialise GTK */
gtk_init (&argc, &argv);
/* Create a new window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Fixed Container");
/* Here we connect the "destroy" event to a signal handler */
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
/* Sets the border width of the window. */
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
/* Create a Fixed Container */
fixed = gtk_fixed_new ();
gtk_container_add (GTK_CONTAINER (window), fixed);
gtk_widget_show (fixed);
for (i = 1 ; i <= 3 ; i++) {
/* Creates a new button with the label "Press me" */
button = gtk_button_new_with_label ("Press me");
/* When the button receives the "clicked" signal, it will call the
* function move_button() passing it the Fixed Container as its
* argument. */
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (move_button), (gpointer) fixed);
/* This packs the button into the fixed containers window. */
gtk_fixed_put (GTK_FIXED (fixed), button, i*50, i*50);
/* The final step is to display this newly created widget. */
gtk_widget_show (button);
}
/* Display the window */
gtk_widget_show (window);
/* Enter the event loop */
gtk_main ();
return 0;
}
static void
drag_data_received_handl(GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
GtkSelectionData *sel_data,
guint info,
guint time,
gpointer data)
{
gint i;
guint candid = GPOINTER_TO_UINT(data);
g_print("%s to dest %d\n",
(gchar *)gtk_selection_data_get_data(sel_data), candid);
i=g_strcmp0((gchar *)gtk_selection_data_get_data(sel_data), "Candidate 1");
switch(i){
case -1:
merged[candid] = 0;
break;
case 0:
merged[candid] = 1;
break;
case 1:
merged[candid] = 2;
break;
default:
break;
}
GtkWidget *source_widget;
GdkPixbuf *source_buf;
GtkWidget *parent;
GdkPixbuf *buf;
GtkWidget *new_widget;
parent = gtk_widget_get_parent(GTK_WIDGET(widget));
source_widget = gtk_drag_get_source_widget(context);
source_widget = gtk_button_get_image(GTK_BUTTON(source_widget));
source_buf = gtk_image_get_pixbuf(GTK_IMAGE(source_widget));
buf = gdk_pixbuf_scale_simple(source_buf, hole_sizes_w[candid],
hole_sizes_h[candid], GDK_INTERP_BILINEAR);
new_widget = gtk_image_new_from_pixbuf(buf);
g_object_unref(buf);
gtk_fixed_put(GTK_FIXED(parent), new_widget, hole_x[candid],
hole_y[candid]);
gtk_widget_show_all(new_widget);
gtk_drag_finish (context, TRUE, FALSE, time);
}
void devolucao ()
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *fixed;
GtkWidget *label;
GtkWidget *entry1, *entry2;
GtkWidget *button;
gint tmp_pos;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (window, FALSE);
gtk_window_set_title (GTK_WINDOW (window), "Devolução de filmes");
gtk_widget_set_size_request (GTK_WIDGET (window), 380, 240);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new ("CPF do cliente:");
gtk_container_add (GTK_CONTAINER (vbox), label);
entry1 = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (entry1), 100);
g_signal_connect (entry1, "changed", G_CALLBACK (enter_devolucao_cpf), entry1);
tmp_pos = GTK_ENTRY (entry1)->text_length;
gtk_editable_select_region (GTK_EDITABLE (entry1), 0, GTK_ENTRY (entry1)->text_length);
gtk_box_pack_start (GTK_BOX (vbox), entry1, TRUE, TRUE, 0);
gtk_widget_show (entry1);
label = gtk_label_new ("Código do filme:");
gtk_container_add (GTK_CONTAINER (vbox), label);
entry2 = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (entry2), 100);
g_signal_connect (entry2, "changed", G_CALLBACK (enter_devolucao_codigo), entry2);
tmp_pos = GTK_ENTRY (entry2)->text_length;
gtk_editable_select_region (GTK_EDITABLE (entry2), 0, GTK_ENTRY (entry2)->text_length);
gtk_box_pack_start (GTK_BOX (vbox), entry2, TRUE, TRUE, 0);
gtk_widget_show (entry2);
fixed = gtk_fixed_new ();
gtk_container_add (GTK_CONTAINER (vbox), fixed);
button = gtk_button_new_with_label ("Ir");
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (devolucao_confirmacao), (gpointer) window);
gtk_fixed_put (GTK_FIXED (fixed), button, 259, 15);
gtk_widget_set_size_request (button, 100, 35);
gtk_widget_show_all (window);
}
