// 构造GUI函数。
// 输入：void
// 返回值：void
void construct_GUI()
{
background = gdk_pixbuf_new_from_file("res/background.jpg",NULL);
A_pic = gdk_pixbuf_new_from_file("res/A.png",NULL);
B_pic = gdk_pixbuf_new_from_file("res/B.png",NULL);
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(main_window,627,570);
gtk_window_set_resizable(GTK_WINDOW(main_window),FALSE);
gtk_window_set_title(GTK_WINDOW(main_window),("Tic Tac toe"));
g_signal_connect(G_OBJECT(main_window),"destroy",G_CALLBACK(gtk_main_quit),NULL);
GtkWidget * layout = gtk_layout_new(NULL,NULL);
gtk_container_add(GTK_CONTAINER(main_window),layout);
GtkWidget * menubar = gtk_menu_bar_new();
GtkWidget * menu1 = gtk_menu_new();
GtkWidget * option = gtk_menu_item_new_with_mnemonic("option");
GtkWidget * player = gtk_image_menu_item_new_with_label("player first");
GtkWidget * computer = gtk_image_menu_item_new_with_label("computer first");
GtkWidget * sep = gtk_separator_menu_item_new();
g_signal_connect(G_OBJECT(player),"activate",G_CALLBACK(player_first),NULL);
g_signal_connect(G_OBJECT(computer),"activate",G_CALLBACK(computer_first),NULL);
GtkWidget * quit = gtk_image_menu_item_new_with_label("quit");
g_signal_connect(G_OBJECT(quit),"activate",G_CALLBACK(gtk_main_quit),NULL);
GtkWidget * menu2 = gtk_menu_new();
GtkWidget * help = gtk_menu_item_new_with_mnemonic("help");
GtkWidget * about = gtk_image_menu_item_new_with_label("about..");
g_signal_connect(G_OBJECT(about),"activate",G_CALLBACK(about_pressed),NULL);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(option),menu1);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),player);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),computer);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),sep);
gtk_menu_shell_append(GTK_MENU_SHELL(menu1),quit);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help),menu2);
gtk_menu_shell_append(GTK_MENU_SHELL(menu2),about);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),option);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),help);
gtk_layout_put(GTK_LAYOUT(layout),menubar,0,0);
gtk_widget_set_size_request(menubar,627,20);
draw_window = gtk_drawing_area_new();
gtk_layout_put(GTK_LAYOUT(layout),draw_window,0,20);
gtk_widget_set_size_request(draw_window,627,570);
g_signal_connect(draw_window,"expose-event",G_CALLBACK(window_drawing),NULL);
gtk_widget_set_events(draw_window,gtk_widget_get_events(draw_window)|GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(draw_window),"button-press-event",G_CALLBACK(when_key_pressed),NULL);
gtk_widget_show_all(main_window);
}
int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *layout;
GtkWidget *but;
int i,j, n;
int x,y;
char text [256];
for (i = 0; i < 16; i++) pos[i]=0;
gtk_init (&argc, &argv);
window = gtk_window_new ( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title (GTK_WINDOW (window),"Fifteen");
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_widget_set_size_request (window, 120,120);
layout = gtk_layout_new (NULL, NULL);
//gtk_layout_set_size (GTK_LAYOUT (layout), 120, 120);
gtk_container_add (GTK_CONTAINER (window), layout);
gtk_widget_show (layout);
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
{
n = gen_pos(4*i+j+1);
x = j*25+10;
y = i*25+10;
if (n == 16)
{
empty_but = gtk_button_new ();
gtk_layout_put (GTK_LAYOUT (layout), empty_but, x, y);
} else {
sprintf (text, "%d", n);
but = gtk_button_new_with_label (text);
gtk_widget_set_size_request (but, 25, 25);
g_signal_connect (G_OBJECT (but), "pressed", G_CALLBACK (but_click), NULL);
gtk_layout_put (GTK_LAYOUT (layout), but, x, y);
gtk_widget_show (but);
}
}
}
gtk_widget_show (window);
gtk_main ();
return 0;
}
void gtk_packing()
{
int i;
gtk_container_add(GTK_CONTAINER(window),layout);
gtk_layout_put(GTK_LAYOUT(layout),bg,0,0);
gtk_layout_put(GTK_LAYOUT(layout),power,10,0);
gtk_layout_put(GTK_LAYOUT(layout),vbox,40,20);
gtk_layout_put(GTK_LAYOUT(layout),close_event,180,0);
for(i=0;i<2;i++)
{
gtk_box_pack_start(GTK_BOX(vbox),label[i],1,1,0);
}
gtk_container_add(GTK_CONTAINER(close_event),close_img);
}
void cb_open (GtkWidget *p_widget)
{
GtkWidget *p_dialog;
p_dialog = gtk_file_chooser_dialog_new ("Image selection", NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
("_Cancel"), GTK_RESPONSE_CANCEL,
("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
if (gtk_dialog_run (GTK_DIALOG (p_dialog)) == GTK_RESPONSE_ACCEPT)
{
//file_name = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (p_dialog));
file_name = g_file_get_path(gtk_file_chooser_get_file(GTK_FILE_CHOOSER(p_dialog)));
if(pImage)
gtk_widget_destroy(pImage);
GdkPixbuf *pBuf = gdk_pixbuf_new_from_file_at_scale (file_name,500,330,TRUE,NULL);
pImage = gtk_image_new_from_pixbuf(pBuf);
g_object_unref (pBuf);
//permet de centrer l'image
GdkPixbuf *pBufFcd = gtk_image_get_pixbuf (GTK_IMAGE(pImage));
int w = gdk_pixbuf_get_width(pBufFcd);
int h = gdk_pixbuf_get_height(pBufFcd);
gtk_layout_put(GTK_LAYOUT(layout), pImage, 273-(w/2), 196-(h/2));
gtk_widget_show_all(pImage);
//g_free(file_name), file_name=NULL;
}
gtk_widget_destroy (p_dialog);
(void)p_widget;
}
/* Widget creators */
extern int NLDT_gtk_button_new(struct lua_State *L)
{
/*
LUA Use:
gtk_button_new("Some Text",Width, Height)
*/
if(lua_gettop(L)!=5)
{
lua_pushstring(L,"ERROR gtk_button_new usage \"Label\", Xpos, Ypos, Width, Height\n");
lua_error(L);
}
char *label = (char*)lua_tostring(L,1);
int x,y,w, h;
x = luaL_checkint(L,2);
y = luaL_checkint(L,3);
w = luaL_checkint(L,4);
h = luaL_checkint(L,5);
GtkWidget *button = gtk_button_new_with_label(label);
gtk_widget_set_size_request(button,w,h);
nldt_gizmo_node *owner = nldt_gizmo_lookup(L);
if(owner==NULL)
{
fprintf(stderr,"ERROR: Attempted to draw before initialisation (Offender: gtk.button_new)\n");
return 0;
}
gtk_layout_put(GTK_LAYOUT(owner->gizmo_space),button,x,y);
gtk_widget_show(button);
lua_pushinteger(L,(int)button);
return 1;
}
extern int NLDT_gtk_button_new_from_image(struct lua_State *L)
{
/*
LUA Use:
gtk_button_new("Some Text",Width, Height)
*/
if(lua_gettop(L)!=3)
{
lua_pushstring(L,"ERROR gtk_button_new_from_image usage \"filename\", Width, Height\n");
lua_error(L);
}
char *file_name = (char*)lua_tostring(L,1);
int w, h;
w = luaL_checkint(L,2);
h = luaL_checkint(L,3);
GtkWidget *button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(button),gtk_image_new_from_file(file_name));
gtk_widget_set_size_request(button,w,h);
nldt_gizmo_node *owner = nldt_gizmo_lookup(L);
if(owner==NULL)
{
fprintf(stderr,"ERROR: Attempted to draw before initialisation (Offender: gtk.button_new_from_image)\n");
return 0;
}
gtk_layout_put(GTK_LAYOUT(owner->gizmo_space),button,10,10);
gtk_widget_show(button);
lua_pushinteger(L,(int)button);
return 1;
}
extern int NLDT_gtk_label_new(struct lua_State *L)
{
/*
LUA Use:
gtk_label_new("Some Text")
*/
if(lua_gettop(L)!=1)
{
lua_pushstring(L,"ERROR gtk_label_new usage \"Label\"\n");
lua_error(L);
}
char *label_text = (char*)lua_tostring(L,1);
GtkWidget *label = gtk_label_new(label_text);
nldt_gizmo_node *owner = nldt_gizmo_lookup(L);
if(owner==NULL)
{
fprintf(stderr,"ERROR: Attempted to draw before initialisation (Offender: gtk.label_new)\n");
return 0;
}
gtk_layout_put(GTK_LAYOUT(owner->gizmo_space),label,10,10);
gtk_widget_show(label);
lua_pushinteger(L,(int)label);
return 1;
}
/*
* 插入框初始化
*/
GtkWidget *CreateInsertWindow() {
// 控件初始化
childInsertWindow.layout = gtk_layout_new(NULL, NULL);
childInsertWindow.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
childInsertWindow.label_puppet = gtk_label_new("新增代理主机地址：");
childInsertWindow.entry_pupper = gtk_entry_new();
childInsertWindow.button_insert = gtk_button_new_with_label("添加");
childInsertWindow.button_cancel = gtk_button_new_with_label("取消");
// 设置控件大小
gtk_widget_set_size_request(childInsertWindow.label_puppet, 120, 30);
gtk_widget_set_size_request(childInsertWindow.entry_pupper, 150, 30);
gtk_widget_set_size_request(childInsertWindow.button_insert, 80, 40);
gtk_widget_set_size_request(childInsertWindow.button_cancel, 80, 40);
//将控件添加到界面
gtk_container_add((GtkContainer *) childInsertWindow.window,
childInsertWindow.layout);
gtk_layout_put((GtkLayout *) childInsertWindow.layout,
childInsertWindow.label_puppet, 10, 20);
gtk_layout_put((GtkLayout *) childInsertWindow.layout,
childInsertWindow.entry_pupper, 140, 20);
gtk_layout_put((GtkLayout *) childInsertWindow.layout,
childInsertWindow.button_insert, 30, 60);
gtk_layout_put((GtkLayout *) childInsertWindow.layout,
childInsertWindow.button_cancel, 180, 60);
gtk_window_set_title(GTK_WINDOW(childInsertWindow.window), "添加被控端主机");
gtk_window_set_position(GTK_WINDOW(childInsertWindow.window),
GTK_WIN_POS_CENTER_ALWAYS);
gtk_widget_set_usize(GTK_WIDGET(childInsertWindow.window), 320, 120);
// 窗口关闭时触发 gtk_widget_destroy 函数
g_signal_connect(G_OBJECT(childInsertWindow.window), "delete_event",
G_CALLBACK(gtk_widget_destroy), childInsertWindow.window);
// 点击取消时触发 gtk_widget_destroy 函数
g_signal_connect(G_OBJECT(childInsertWindow.button_cancel), "clicked",
G_CALLBACK(tfn_insert_cancel), childInsertWindow.window);
// 点击取消时触发 gtk_widget_destroy 函数
g_signal_connect(G_OBJECT(childInsertWindow.button_insert), "clicked",
G_CALLBACK(tfn_insert_insert), childInsertWindow.window);
return childInsertWindow.window;
}
void gtk_hexgrid_put(GtkHexGrid* hexgrid, GtkWidget* child, int x, int y)
{
int real_x = P(hexgrid)->width / 2 - P(hexgrid)->button_size +
3 * x * P(hexgrid)->button_size / 2;
int real_y = abs(x) * (P(hexgrid)->button_size + 1) +
2 * y * P(hexgrid)->button_size;
gtk_widget_set_size_request(child, 2 * P(hexgrid)->button_size,
P(hexgrid)->button_size * 2);
gtk_layout_put(GTK_LAYOUT(hexgrid), child, real_x, real_y);
}
int
clip_GTK_LAYOUTPUT(ClipMachine * cm)
{
C_widget *ccon = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
gint x = _clip_parni(cm,3);
gint y = _clip_parni(cm,4);
CHECKARG2(2,MAP_t,NUMERIC_t);
CHECKOPT(3,NUMERIC_t); CHECKOPT(4,NUMERIC_t);
CHECKCWID(ccon,GTK_IS_LAYOUT); CHECKCWID(cwid,GTK_IS_WIDGET);
if (_clip_parinfo(cm,3) == UNDEF_t) x = cwid->widget->allocation.x;
if (_clip_parinfo(cm,4) == UNDEF_t) y = cwid->widget->allocation.y;
gtk_layout_put(GTK_LAYOUT(ccon->widget), cwid->widget, x,y);
return 0;
err:
return 1;
}
void populate(GtkLayout * l) {
for(int i = COLUMNS; i >= 0; i--) {
for(int x = ROWS; x >= 0; x--) {
GtkWidget * lbl = gtk_label_new(" ");
gtk_widget_set_size_request(lbl, 25, 25);
gtk_layout_put (l,
lbl,
i * 50,
x * 50);
int bx = (x - ROWS) * -1;
int bi = (i - COLUMNS) * -1;
// printf("%d - %d \r\n", bi, bx);
buff2[bi][bx] = lbl;
}
}
}
static void
draw (HTMLObject *o,
HTMLPainter *p,
gint x,
gint y,
gint width,
gint height,
gint tx,
gint ty)
{
HTMLEmbedded *element = HTML_EMBEDDED (o);
gint new_x, new_y;
d (printf ("draw embedded %p\n", element));
if (!element->widget)
return;
if (element->parent) {
GtkWidget *parent;
new_x = o->x + tx;
new_y = o->y + ty - o->ascent;
if ((parent = gtk_widget_get_parent (element->widget))) {
if (new_x != element->abs_x || new_y != element->abs_y) {
d (printf ("element: %p moveto: %d,%d shown: %d\n", element, new_x, new_y, GTK_WIDGET_VISIBLE (element->widget)));
gtk_layout_move (GTK_LAYOUT (parent), element->widget, new_x, new_y);
} else if (!GTK_HTML (parent)->engine->expose)
gtk_widget_queue_draw (element->widget);
}
element->abs_x = new_x;
element->abs_y = new_y;
if (!parent) {
d (printf ("element: %p put: %d,%d shown: %d\n", element, new_x, new_y, GTK_WIDGET_VISIBLE (element->widget)));
gtk_layout_put (GTK_LAYOUT (element->parent), element->widget, new_x, new_y);
}
}
d (printf ("draw embedded %p - call painter tx %d ty %d\n", element, tx, ty));
html_painter_draw_embedded (p, element, tx, ty);
}
GtkComboBox *get_SelectGraph(void)
{
GtkComboBox *cb;
if (!cbSelectGraph) {
cb = (GtkComboBox *) gtk_combo_box_new_text();
gtk_widget_show((GtkWidget *) cb);
gtk_box_pack_start(GTK_BOX(gladewidget), (GtkWidget *) cb, FALSE,
FALSE, 0);
gtk_layout_put((GtkLayout *) gladewidget, (GtkWidget *) cb, 780,
3);
//signal
return cb;
} else
return cbSelectGraph;
}
void drawbutton(GtkWidget *layout,gchar *tname,gint x,gint y,gint type,MrpProject *project)
{
GtkWidget *button;
gboolean sensitive;
sensitive = type;
gchar *buttonname = tname;
button = gtk_button_new_with_label (buttonname);
gtk_layout_put(layout,button,x,y);
//gtk_widget_set_size_request(button, WIDTH12,HIGH12);
gtk_widget_set_size_request(button, 95,50);
gtk_widget_set_name (button,tname);
font1 = pango_font_description_from_string("Sans");//"Sans"字体名
pango_font_description_set_size(font1, fontSize * PANGO_SCALE);//设置字体大小
labelChild = gtk_bin_get_child(GTK_BIN( button));//取出GtkButton里的label
pango_font_description_set_weight(font1,700);
gtk_widget_modify_font(GTK_WIDGET(labelChild), font1);//设置label的字体， 这样这个GtkButton上面显示的字体就变了
gtk_widget_set_sensitive(button,sensitive);
if(sensitive)
{
GdkColor color1;
color1.red = 0;
color1.green = 50100;
color1.blue = 50000;
gtk_widget_modify_bg(button, GTK_STATE_NORMAL, &color1);
}
buttons = g_list_prepend(buttons,button);
gtk_widget_show (button);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (reDrawd),
project);
}
GtkComboBox *get_SelectGraph()
{
GtkComboBox *cb;
if (!cbSelectGraph) {
cb = (GtkComboBox *) gtk_combo_box_new_text();
gtk_widget_show((GtkWidget *) cb);
gladewidget = glade_xml_get_widget(xml, "layout6");
gtk_box_pack_start(GTK_BOX(gladewidget), (GtkWidget *) cb, FALSE,
FALSE, 0);
gtk_layout_put((GtkLayout *) gladewidget, (GtkWidget *) cb, 780,
3);
//signal
g_signal_connect((gpointer) cb, "changed",
G_CALLBACK(graph_select_change), NULL);
return cb;
} else
return cbSelectGraph;
}
void
redrawGertToPert(GtkWidget *widget,gpointer data)
{
GtkWidget *layout;
GtkWidget *scrollwindows;
layout = gtk_widget_get_parent(widget);
g_printf("redraw the pert node,name is %s\n",data);
//gtk_widget_hide(layout);
scrollwindows = gtk_widget_get_parent(layout);
gtk_container_remove(scrollwindows,layout);
GtkWidget *newlayout;
GtkWidget *button;
newlayout = gtk_layout_new(NULL,NULL);
button=gtk_button_new_with_label("改变主窗口label文字");
gtk_layout_put(newlayout, button, 497, 250);
gtk_widget_set_size_request(button, 80, 65);
gtk_container_add(GTK_CONTAINER(scrollwindows), newlayout);
gtk_widget_show(newlayout);
gtk_widget_show_all(scrollwindows);
}
int handle_message_box(GladeXML* g_glade_xml, GtkLayout* screen, int init)
{
char* message = get_string();
if (init)
{
g_message_window = glade_xml_get_widget(g_glade_xml,
"message_window");
g_assert(g_message_window);
set_nil_draw_focus(g_message_window);
if(screen) gtk_layout_put(screen, g_message_window, 0, 0);
g_message_label = glade_xml_get_widget(g_glade_xml,
"message_label");
g_assert(g_message_label);
GUI_BRANCH(g_glade_xml, on_okbutton1_clicked);
}
gtk_label_set_text(GTK_LABEL(g_message_label), message);
g_free(message);
gui_center(g_message_window, screen);
return TRUE;
}
GtkWidget *
gnc_item_edit_new (GnucashSheet *sheet)
{
char *hpad_str, *vpad_str, *entry_css;
GtkStyleContext *stylecontext;
GtkCssProvider *provider;
GncItemEdit *item_edit =
g_object_new (GNC_TYPE_ITEM_EDIT,
"sheet", sheet,
"spacing", 0,
"homogeneous", FALSE,
NULL);
gtk_layout_put (GTK_LAYOUT(sheet), GTK_WIDGET(item_edit), 0, 0);
// This sets a style class for when Gtk+ version is less than 3.20
gnc_widget_set_css_name (GTK_WIDGET(item_edit), "cursor");
/* Create the text entry */
item_edit->editor = gtk_entry_new();
sheet->entry = item_edit->editor;
gtk_entry_set_width_chars (GTK_ENTRY(item_edit->editor), 1);
gtk_box_pack_start (GTK_BOX(item_edit), item_edit->editor, TRUE, TRUE, 0);
// Make sure the Entry can not have focus and no frame
gtk_widget_set_can_focus (GTK_WIDGET(item_edit->editor), FALSE);
gtk_entry_set_has_frame (GTK_ENTRY(item_edit->editor), FALSE);
// Connect to the draw signal so we can draw a cursor
g_signal_connect_after (item_edit->editor, "draw",
G_CALLBACK (draw_text_cursor_cb), NULL);
// Fill in the background so the underlying sheet cell can not be seen
g_signal_connect (item_edit, "draw",
G_CALLBACK (draw_background_cb), item_edit);
/* Force padding on the entry to align with the rest of the register this
is done in the gnucash.css file which should be in line with sheet.h */
/* Create the popup button
It will only be displayed when the cell being edited provides
a popup item (like a calendar or account list) */
item_edit->popup_toggle.tbutton = gtk_toggle_button_new();
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (item_edit->popup_toggle.tbutton), FALSE);
/* Force padding on the button to keep it small and display as much as
possible of the arrow which is done in the gnucash.css file */
/* Wrap the popup button in an event box to give it its own gdkwindow.
* Without one the button would disappear behind the grid object. */
item_edit->popup_toggle.ebox = gtk_event_box_new();
g_object_ref(item_edit->popup_toggle.ebox);
gtk_container_add(GTK_CONTAINER(item_edit->popup_toggle.ebox),
item_edit->popup_toggle.tbutton);
gtk_box_pack_start (GTK_BOX(item_edit),
item_edit->popup_toggle.ebox,
FALSE, TRUE, 0);
gtk_widget_show_all(GTK_WIDGET(item_edit));
return GTK_WIDGET(item_edit);
}
int handle_cashier(GladeXML* s_glade_personal_information_xml, GladeXML* s_glade_account_status_xml, GladeXML* s_glade_exit_cashier_xml, GtkLayout* screen, int init)
{
if (init)
{
s_personal_information_window =
gui_get_widget(s_glade_personal_information_xml,
"personal_information_window");
g_assert(s_personal_information_window);
set_nil_draw_focus(s_personal_information_window);
if(screen) gtk_layout_put(screen, s_personal_information_window, 0, 0);
s_account_status_window =
gui_get_widget(s_glade_account_status_xml,
"account_status_window");
g_assert(s_account_status_window);
if(screen) gtk_layout_put(screen, s_account_status_window, 0, 0);
s_exit_cashier_window = gui_get_widget(s_glade_exit_cashier_xml, "exit_cashier_window");
g_assert(s_exit_cashier_window);
if(screen) gtk_layout_put(screen, s_exit_cashier_window, 0, 0);
s_exit_button = GTK_BUTTON(gui_get_widget(s_glade_exit_cashier_xml, "exit_cashier"));
g_assert(s_exit_button);
{
static const char* entries[ENTRIES_CNT] =
{
"entry_player_id",
"entry_email",
};
int i;
for (i = 0; i < ENTRIES_CNT; i++)
s_entries[i] = gui_get_widget(s_glade_personal_information_xml,
entries[i]);
}
{
static const char* labels[LABELS_CNT] =
{
"money_one_available",
"money_one_in_game",
"money_one_total",
"money_two_available",
"money_two_in_game",
"money_two_total"
};
int i;
for (i = 0; i < LABELS_CNT; i++)
s_labels[i] = gui_get_widget(s_glade_account_status_xml,
labels[i]);
}
GUI_BRANCH(s_glade_exit_cashier_xml, on_exit_cashier_clicked);
gtk_widget_hide(s_personal_information_window);
gtk_widget_hide(s_account_status_window);
gtk_widget_hide(s_exit_cashier_window);
}
char* showhide = get_string();
char* fields[20];
char** pfields = fields;
int i = get_int();
int fields_cnt = 0;
if(i > 0) {
g_message("cashier got %d entries", i);
while (i-- > 0)
{
char* str = get_string();
if (fields_cnt < 20)
fields[fields_cnt++] = str;
}
for (i = 0; i < ENTRIES_CNT; i++)
{
char* str = *pfields++;
gtk_entry_set_text(GTK_ENTRY(s_entries[i]), str);
}
{
char* str = *pfields++;
GtkTextView* address = GTK_TEXT_VIEW(gui_get_widget(s_glade_personal_information_xml, "entry_mailing_address"));
GtkTextBuffer* buffer = gtk_text_view_get_buffer(address);
gtk_text_buffer_set_text(buffer, str, -1);
}
for (i = 0; i < LABELS_CNT; i++)
{
char* str = *pfields++;
gtk_label_set_text(GTK_LABEL(s_labels[i]), str);
}
for (i = 0; i < fields_cnt; i++) {
g_free(fields[i]);
}
}
if(!strcmp(showhide, "show")) {
/*
* calculate windows position
*/
int screen_width = gui_width(screen);
int screen_height = gui_height(screen);
/*
* should be based on the size of the windows ...
*/
int top_left_x = (screen_width - 913) / 2;
int top_left_y = (screen_height - 450) / 2;
int account_status_x = top_left_x + 381;
int exit_cashier_y = top_left_y + 320;
s_personal_information_position.x = top_left_x;
s_personal_information_position.y = top_left_y;
s_account_status_position.x = account_status_x;
s_account_status_position.y = top_left_y;
s_exit_cashier_position.x = top_left_x;
s_exit_cashier_position.y = exit_cashier_y;
{
char* label = get_string();
gtk_button_set_label(s_exit_button, label);
g_free(label);
}
{
//moneyone
GtkWidget* sl = gui_get_widget(s_glade_account_status_xml, "money_one_name");
char* label = get_string();
gtk_label_set_text(GTK_LABEL(sl), label);
g_free(label);
}
{
//moneytwo
GtkWidget* sl = gui_get_widget(s_glade_account_status_xml, "money_two_name");
char* label = get_string();
gtk_label_set_text(GTK_LABEL(sl), label);
g_free(label);
}
if ((screen != NULL) || (s_cashier_shown == 0))
{
gui_place(s_personal_information_window, &s_personal_information_position, screen);
gui_place(s_account_status_window, &s_account_status_position, screen);
gui_place(s_exit_cashier_window, &s_exit_cashier_position, screen);
s_cashier_shown = 1;
}
} else {
if (screen != NULL)
{
hide_cashier();
}
}
g_free(showhide);
return TRUE;
}
static void timing_inst_layout_refresh(struct vgpu_compute_unit_t *compute_unit)
{
struct vgpu_uop_t *uop;
int x, y, top_y;
int i;
/* Check if diagram needs to get recalculated */
if (timing_dia_needs_refresh(compute_unit))
timing_dia_refresh(compute_unit);
/* Remove all child widgets in 'timing_inst_layout' */
gtk_container_destroy_children(GTK_CONTAINER(compute_unit->timing_inst_layout));
/* White background */
GdkColor color;
gdk_color_parse("white", &color);
/* Attributes for labels */
PangoAttrList *attrs;
PangoAttribute *size_attr;
attrs = pango_attr_list_new();
size_attr = pango_attr_size_new_absolute(13 << 10);
pango_attr_list_insert(attrs, size_attr);
/* Instruction list */
top_y = -((int) compute_unit->timing_dia_vscrollbar_value % timing_dia_row_height);
y = top_y;
for (i = 0; i < compute_unit->timing_dia_height; i++)
{
char text[MAX_STRING_SIZE];
GtkWidget *label;
GtkWidget *event_box;
GtkRequisition req;
uop = list_get(compute_unit->timing_inst_uops, i);
if (uop)
{
/* Create label + event box for 'I-x' */
x = 0;
snprintf(text, sizeof text, "I-%d", uop->id);
label = gtk_label_new(text);
event_box = gtk_event_box_new();
gtk_widget_modify_bg(event_box, GTK_STATE_NORMAL, &color);
gtk_container_add(GTK_CONTAINER(event_box), label);
gtk_layout_put(GTK_LAYOUT(compute_unit->timing_inst_layout), event_box, x, y);
gtk_widget_set_size_request(event_box, 40, timing_dia_row_height);
gtk_label_set_attributes(GTK_LABEL(label), attrs);
g_signal_connect(G_OBJECT(event_box), "enter-notify-event", G_CALLBACK(list_layout_label_enter_notify_event), NULL);
g_signal_connect(G_OBJECT(event_box), "leave-notify-event", G_CALLBACK(list_layout_label_leave_notify_event), NULL);
g_signal_connect(G_OBJECT(event_box), "button-press-event", G_CALLBACK(timing_inst_layout_clicked_event), uop);
/* Create label + event box for instruction name */
x = 42;
label = gtk_label_new(NULL);
event_box = gtk_event_box_new();
gtk_widget_modify_bg(event_box, GTK_STATE_NORMAL, &color);
vgpu_uop_get_markup(uop, text, sizeof(text));
gtk_label_set_markup(GTK_LABEL(label), text);
gtk_container_add(GTK_CONTAINER(event_box), label);
gtk_layout_put(GTK_LAYOUT(compute_unit->timing_inst_layout), event_box, x, y);
gtk_widget_size_request(label, &req);
gtk_widget_set_size_request(event_box, req.width, timing_dia_row_height);
gtk_label_set_attributes(GTK_LABEL(label), attrs);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
}
y += timing_dia_row_height;
}
gtk_widget_show_all(compute_unit->timing_inst_layout);
}
/*
* 画主界面
*/
GtkWidget *CreateMainWindow() {
// 控件初始化
mainWindow.layout = gtk_layout_new(NULL, NULL);
mainWindow.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
mainWindow.list_puppet = gtk_tree_view_new();
mainWindow.entry_target = gtk_entry_new();
mainWindow.label_puppet = gtk_label_new("代理端主机列表：");
mainWindow.label_method = gtk_label_new("攻击方式：");
mainWindow.label_target = gtk_label_new("目标主机地址：");
mainWindow.button_attack = gtk_button_new_with_label("攻击");
mainWindow.button_stop = gtk_button_new_with_label("停止");
mainWindow.button_quit = gtk_button_new_with_label("退出");
mainWindow.button_insert = gtk_button_new_with_label("新增");
mainWindow.button_delete = gtk_button_new_with_label("删除");
mainWindow.checkbutton_icmp = gtk_check_button_new_with_label("ICMP Flood");
mainWindow.checkbutton_tcp = gtk_check_button_new_with_label("TCP Flood");
mainWindow.checkbutton_udp = gtk_check_button_new_with_label("UDP Flood");
mainWindow.selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(mainWindow.list_puppet));
// 设置控件大小
gtk_widget_set_size_request(mainWindow.list_puppet, 200, 150);
gtk_widget_set_size_request(mainWindow.entry_target, 200, 30);
gtk_widget_set_size_request(mainWindow.label_puppet, 100, 30);
gtk_widget_set_size_request(mainWindow.label_target, 100, 30);
gtk_widget_set_size_request(mainWindow.label_method, 60, 30);
gtk_widget_set_size_request(mainWindow.button_attack, 80, 40);
gtk_widget_set_size_request(mainWindow.button_stop, 80, 40);
gtk_widget_set_size_request(mainWindow.button_quit, 80, 40);
gtk_widget_set_size_request(mainWindow.button_insert, 80, 40);
gtk_widget_set_size_request(mainWindow.button_delete, 80, 40);
gtk_widget_set_size_request(mainWindow.checkbutton_icmp, 120, 20);
gtk_widget_set_size_request(mainWindow.checkbutton_tcp, 100, 20);
gtk_widget_set_size_request(mainWindow.checkbutton_udp, 100, 20);
//将控件添加到界面
gtk_container_add((GtkContainer *) mainWindow.window, mainWindow.layout);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.list_puppet, 20,
50);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.entry_target,
130, 280);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.label_puppet, 20,
20);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.label_method, 20,
220);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.label_target, 20,
280);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.button_attack,
20, 330);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.button_stop, 140,
330);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.button_quit, 260,
330);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.button_insert,
240, 50);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.button_delete,
240, 160);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.checkbutton_icmp,
20, 245);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.checkbutton_tcp,
140, 245);
gtk_layout_put((GtkLayout *) mainWindow.layout, mainWindow.checkbutton_udp,
260, 245);
init_list(mainWindow.list_puppet);
// 设置主窗口标题
gtk_window_set_title(GTK_WINDOW(mainWindow.window), "TFN2k 测试版");
// 设置主窗口大小
gtk_widget_set_usize(GTK_WIDGET(mainWindow.window), 360, 390);
// 设置主窗口位置
gtk_window_set_position(GTK_WINDOW(mainWindow.window),
GTK_WIN_POS_CENTER_ALWAYS);
// 设置窗口图标
gtk_window_set_icon(GTK_WINDOW(mainWindow.window),
create_pixbuf("images/web.png"));
// 设置窗口大小不可更改
gtk_window_set_resizable(GTK_WINDOW(mainWindow.window), FALSE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(mainWindow.list_puppet), FALSE);
// 点击quit键，回调gtk_main_quit函数
g_signal_connect(mainWindow.window, "destroy", G_CALLBACK(gtk_main_quit),
NULL);
// 点击退出键，回调gtk_main_quit函数
g_signal_connect(mainWindow.button_quit, "clicked",
G_CALLBACK(gtk_main_quit), NULL);
// 点击攻击键，回调tfn_main_attack函数
g_signal_connect(mainWindow.button_attack, "clicked",
G_CALLBACK(tfn_main_attack), NULL);
// 点击停止键，回调tfn_main_stop函数
g_signal_connect(mainWindow.button_stop, "clicked",
G_CALLBACK(tfn_main_stop), NULL);
// 点击新增键，回调tfn_main_insert函数
g_signal_connect(mainWindow.button_insert, "clicked",
G_CALLBACK(tfn_main_insert), NULL);
// 点击删除键，回调tfn_main_delete函数
g_signal_connect(mainWindow.button_delete, "clicked",
G_CALLBACK(tfn_main_delete), mainWindow.selection);
return mainWindow.window;
}
gboolean set_widgets_defaults(GtkWidget *mvbox, track_t *t, GdkRGBA *color)
{
GtkWidget *hbox, *vbox, *label, *hbox2,
*sep, *button, *img, *eventBox;
gint i = 0;
GdkRGBA buttonNormal = {1, 1, 1, 0.2};
GdkRGBA buttonSelected = {1, 1, 1, 0.6};
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start(GTK_BOX(mvbox), hbox, 0, 0, 1);
/* album image */
eventBox = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(eventBox), 0);
gtk_widget_set_events(eventBox, GDK_BUTTON_PRESS_MASK);
t->trackw.image = gtk_image_new();
gtk_container_add(GTK_CONTAINER(eventBox), t->trackw.image);
g_signal_connect(eventBox, "button_press_event", G_CALLBACK(show_player_callback), NULL);
gtk_box_pack_start(GTK_BOX(hbox), eventBox, 0, 0, 0);
/* track info: name, artist, album */
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, 0, 0, 0);
t->trackw.label.name = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.label.name), 0, 0);
/* create the layout to be able to scrol the label's contents */
t->trackw.layout.name = gtk_layout_new(NULL, NULL);
/* set size otherwise it won't show up */
gtk_widget_set_size_request(t->trackw.layout.name, SCROLL_SIZE_W, SCROLL_SIZE_H);
/* make layout's color the same as the window's */
gtk_widget_override_background_color(t->trackw.layout.name, GTK_STATE_FLAG_NORMAL, color);
gtk_layout_put(GTK_LAYOUT(t->trackw.layout.name), t->trackw.label.name, 0, 0);
t->trackw.label.artist = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.label.artist), 0, 0);
t->trackw.layout.artist = gtk_layout_new(NULL, NULL);
gtk_widget_set_size_request(t->trackw.layout.artist, SCROLL_SIZE_W-23, SCROLL_SIZE_H);
gtk_widget_override_background_color(t->trackw.layout.artist, GTK_STATE_FLAG_NORMAL, color);
gtk_layout_put(GTK_LAYOUT(t->trackw.layout.artist), t->trackw.label.artist, 0, 0);
t->trackw.label.album = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.label.album), 0, 0);
t->trackw.layout.album = gtk_layout_new(NULL, NULL);
gtk_widget_set_size_request(t->trackw.layout.album, SCROLL_SIZE_W-40, SCROLL_SIZE_H);
gtk_widget_override_background_color(t->trackw.layout.album, GTK_STATE_FLAG_NORMAL, color);
gtk_layout_put(GTK_LAYOUT(t->trackw.layout.album), t->trackw.label.album, 0, 0);
/* put the name, artist and album at their places */
gtk_box_pack_start(GTK_BOX(vbox), t->trackw.layout.name, 0, 0, 0);
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, 0, 0, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_label_set_markup(GTK_LABEL(label), "<span font='Sans 11' font_style='italic'"
"color='#FFFFFF'>by </span>");
gtk_box_pack_start(GTK_BOX(hbox2), label, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.layout.artist, 0, 0, 0);
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, 0, 0, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_label_set_markup(GTK_LABEL(label), "<span font='Sans 11' font_style='italic'"
"color='#FFFFFF'>from </span>");
gtk_box_pack_start(GTK_BOX(hbox2), label, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.layout.album, 0, 0, 0);
/* puts the genre, rating, year, and playcount */
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, 0, 0, 0);
t->trackw.genre = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.genre), 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.genre, 0, 0, 0);
sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start(GTK_BOX(hbox2), sep, 0, 0, 3);
for (i = 0; i < 5; i++) {
t->trackw.stars[i] = gtk_image_new();
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.stars[i], 0, 0, 1);
}
sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start(GTK_BOX(hbox2), sep, 0, 0, 3);
t->trackw.year = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.year), 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.year, 0, 0, 0);
sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start(GTK_BOX(hbox2), sep, 0, 0, 3);
t->trackw.playcount = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.playcount), 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.playcount, 0, 0, 0);
/* puts the current position, the slider showing the progress
* and track length */
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, 0, 0, 0);
t->trackw.position = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.position), 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.position, 0, 0, 0);
t->trackw.slider = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, NULL);
gtk_widget_set_size_request(t->trackw.slider, 170, -1);
gtk_scale_set_draw_value(GTK_SCALE(t->trackw.slider), 0);
gtk_range_set_show_fill_level(GTK_RANGE(t->trackw.slider), 1);
gtk_range_set_restrict_to_fill_level(GTK_RANGE(t->trackw.slider), 0);
/*g_signal_connect(t->trackw.slider, "value-changed", G_CALLBACK(slider_value_changed), NULL);*/
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.slider, 0, 0, 0);
t->trackw.length = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(t->trackw.length), 0, 0);
gtk_box_pack_start(GTK_BOX(hbox2), t->trackw.length, 0, 0, 0);
/* the player controls */
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(mvbox), hbox, 0, 0, 0);
img = gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_xpm_data(prev_xpm));
button = gtk_button_new();
gtk_widget_override_background_color(button, GTK_STATE_FLAG_NORMAL, &buttonNormal);
gtk_widget_override_background_color(button, GTK_STATE_FLAG_ACTIVE, &buttonSelected);
gtk_container_add(GTK_CONTAINER(button), img);
g_signal_connect(button, "clicked", G_CALLBACK(button_callback),
GINT_TO_POINTER(BUTTON_PREV));
gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 0);
t->playerControls.playPause = gtk_image_new();
button = gtk_button_new();
gtk_widget_override_background_color(button, GTK_STATE_FLAG_NORMAL, &buttonNormal);
gtk_widget_override_background_color(button, GTK_STATE_FLAG_ACTIVE, &buttonSelected);
gtk_container_add(GTK_CONTAINER(button), t->playerControls.playPause);
g_signal_connect(button, "clicked", G_CALLBACK(button_callback),
GINT_TO_POINTER(BUTTON_PLAY_PAUSE));
gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 0);
img = gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_xpm_data(next_xpm));
button = gtk_button_new();
gtk_widget_override_background_color(button, GTK_STATE_FLAG_NORMAL, &buttonNormal);
gtk_widget_override_background_color(button, GTK_STATE_FLAG_ACTIVE, &buttonSelected);
gtk_container_add(GTK_CONTAINER(button), img);
g_signal_connect(button, "clicked", G_CALLBACK(button_callback),
GINT_TO_POINTER(BUTTON_NEXT));
gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 0);
sep = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start(GTK_BOX(hbox), sep, 0, 0, 2);
t->playerControls.repeat = gtk_image_new();
button = gtk_button_new();
gtk_widget_override_background_color(button, GTK_STATE_FLAG_NORMAL, &buttonNormal);
gtk_widget_override_background_color(button, GTK_STATE_FLAG_ACTIVE, &buttonSelected);
gtk_container_add(GTK_CONTAINER(button), t->playerControls.repeat);
g_signal_connect(button, "clicked", G_CALLBACK(button_callback),
GINT_TO_POINTER(BUTTON_REPEAT));
gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 0);
t->playerControls.shuffle = gtk_image_new();
button = gtk_button_new();
gtk_widget_override_background_color(button, GTK_STATE_FLAG_NORMAL, &buttonNormal);
gtk_widget_override_background_color(button, GTK_STATE_FLAG_ACTIVE, &buttonSelected);
gtk_container_add(GTK_CONTAINER(button), t->playerControls.shuffle);
g_signal_connect(button, "clicked", G_CALLBACK(button_callback),
GINT_TO_POINTER(BUTTON_SHUFFLE));
gtk_box_pack_start(GTK_BOX(hbox), button, 0, 0, 0);
return TRUE;
}
MimeView *mimeview_create(MainWindow *mainwin)
{
MimeView *mimeview;
GtkWidget *paned;
GtkWidget *scrolledwin;
GtkWidget *ctree;
GtkWidget *mime_notebook;
GtkWidget *popupmenu;
GtkWidget *ctree_mainbox;
GtkWidget *vbox;
GtkWidget *mime_toggle;
GtkWidget *icon_mainbox;
GtkWidget *icon_scroll;
GtkWidget *icon_vbox;
GtkWidget *arrow;
GtkWidget *scrollbutton;
GtkWidget *hbox;
GtkTooltips *tooltips;
GtkItemFactory *popupfactory;
NoticeView *siginfoview;
gchar *titles[N_MIMEVIEW_COLS];
gint n_entries;
gint i;
debug_print("Creating MIME view...\n");
mimeview = g_new0(MimeView, 1);
titles[COL_MIMETYPE] = _("MIME Type");
titles[COL_SIZE] = _("Size");
titles[COL_NAME] = _("Name");
scrolledwin = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwin);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
ctree = gtk_sctree_new_with_titles(N_MIMEVIEW_COLS, 0, titles);
gtk_widget_show(ctree);
gtk_clist_set_selection_mode(GTK_CLIST(ctree), GTK_SELECTION_BROWSE);
gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_NONE);
gtk_clist_set_column_justification(GTK_CLIST(ctree), COL_SIZE,
GTK_JUSTIFY_RIGHT);
gtk_clist_set_column_width(GTK_CLIST(ctree), COL_MIMETYPE, 240);
gtk_clist_set_column_width(GTK_CLIST(ctree), COL_SIZE, 90);
for (i = 0; i < N_MIMEVIEW_COLS; i++)
GTK_WIDGET_UNSET_FLAGS(GTK_CLIST(ctree)->column[i].button,
GTK_CAN_FOCUS);
gtk_container_add(GTK_CONTAINER(scrolledwin), ctree);
gtk_signal_connect(GTK_OBJECT(ctree), "tree_select_row",
GTK_SIGNAL_FUNC(mimeview_selected), mimeview);
gtk_signal_connect(GTK_OBJECT(ctree), "button_release_event",
GTK_SIGNAL_FUNC(mimeview_button_pressed), mimeview);
gtk_signal_connect(GTK_OBJECT(ctree), "key_press_event",
GTK_SIGNAL_FUNC(mimeview_key_pressed), mimeview);
gtk_signal_connect(GTK_OBJECT (ctree),"start_drag",
GTK_SIGNAL_FUNC (mimeview_start_drag), mimeview);
gtk_signal_connect(GTK_OBJECT(ctree), "drag_data_get",
GTK_SIGNAL_FUNC(mimeview_drag_data_get), mimeview);
mime_notebook = gtk_notebook_new();
gtk_widget_show(mime_notebook);
GTK_WIDGET_UNSET_FLAGS(mime_notebook, GTK_CAN_FOCUS);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(mime_notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(mime_notebook), FALSE);
icon_vbox = gtk_vbox_new(FALSE, 2);
gtk_widget_show(icon_vbox);
icon_scroll = gtk_layout_new(NULL, NULL);
gtk_widget_show(icon_scroll);
gtk_layout_put(GTK_LAYOUT(icon_scroll), icon_vbox, 0, 0);
scrollbutton = gtk_vscrollbutton_new(gtk_layout_get_vadjustment(GTK_LAYOUT(icon_scroll)));
gtk_widget_show(scrollbutton);
mime_toggle = gtk_toggle_button_new();
gtk_widget_show(mime_toggle);
arrow = gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_NONE);
gtk_widget_show(arrow);
gtk_container_add(GTK_CONTAINER(mime_toggle), arrow);
gtk_signal_connect(GTK_OBJECT(mime_toggle), "toggled",
GTK_SIGNAL_FUNC(mime_toggle_button_cb), mimeview);
icon_mainbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(icon_mainbox);
gtk_box_pack_start(GTK_BOX(icon_mainbox), mime_toggle, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(icon_mainbox), icon_scroll, TRUE, TRUE, 3);
gtk_box_pack_end(GTK_BOX(icon_mainbox), scrollbutton, FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(icon_mainbox), "size_allocate",
GTK_SIGNAL_FUNC(icon_scroll_size_allocate_cb), mimeview);
ctree_mainbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(ctree_mainbox), scrolledwin, TRUE, TRUE, 0);
n_entries = sizeof(mimeview_popup_entries) /
sizeof(mimeview_popup_entries[0]);
popupmenu = menu_create_items(mimeview_popup_entries, n_entries,
"<MimeView>", &popupfactory, mimeview);
tooltips = gtk_tooltips_new();
gtk_tooltips_set_delay(tooltips, 0);
vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox);
siginfoview = noticeview_create(mainwin);
noticeview_hide(siginfoview);
gtk_box_pack_start(GTK_BOX(vbox), mime_notebook, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), GTK_WIDGET_PTR(siginfoview), FALSE, FALSE, 0);
paned = gtk_vpaned_new();
gtk_widget_show(paned);
gtk_paned_set_gutter_size(GTK_PANED(paned), 0);
gtk_paned_pack1(GTK_PANED(paned), ctree_mainbox, FALSE, TRUE);
gtk_paned_pack2(GTK_PANED(paned), vbox, TRUE, TRUE);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), paned, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), icon_mainbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
gtk_widget_hide(ctree_mainbox);
mimeview->hbox = hbox;
mimeview->paned = paned;
mimeview->scrolledwin = scrolledwin;
mimeview->ctree = ctree;
mimeview->mime_notebook = mime_notebook;
mimeview->popupmenu = popupmenu;
mimeview->popupfactory = popupfactory;
mimeview->type = -1;
mimeview->ctree_mainbox = ctree_mainbox;
mimeview->icon_scroll = icon_scroll;
mimeview->icon_vbox = icon_vbox;
mimeview->icon_mainbox = icon_mainbox;
mimeview->icon_count = 0;
mimeview->mainwin = mainwin;
mimeview->tooltips = tooltips;
mimeview->oldsize = 60;
mimeview->mime_toggle = mime_toggle;
mimeview->siginfoview = siginfoview;
mimeview->target_list = gtk_target_list_new(mimeview_mime_types, 1);
mimeviews = g_slist_prepend(mimeviews, mimeview);
return mimeview;
}
void FloatingWindow::display(bool startup)
// Does the bookkeeping necessary for displaying the floating box.
// startup: whether the box is started at program startup.
{
// Settings.
extern Settings *settings;
// The parameters of all the windows.
WindowData window_parameters(false);
// Clear the new window's position.
my_gdk_rectangle.x = 0;
my_gdk_rectangle.y = 0;
my_gdk_rectangle.width = 0;
my_gdk_rectangle.height = 0;
// At program startup extract the position and size of the window from the general configuration.
// It does not matter whether the space for the window is already taken up by another window,
// because the user wishes to use the coordinates that he has set for this window.
for (unsigned int i = 0; i < window_parameters.widths.size(); i++) {
if ((window_parameters.ids[i] == window_id) && (window_parameters.titles[i] == title) && startup) {
my_gdk_rectangle.x = window_parameters.x_positions[i];
my_gdk_rectangle.y = window_parameters.y_positions[i];
my_gdk_rectangle.width = window_parameters.widths[i];
my_gdk_rectangle.height = window_parameters.heights[i];
}
}
// Reject zero width and zero height values on startup.
if ((my_gdk_rectangle.width == 0) || (my_gdk_rectangle.height == 0))
startup = false;
// When a new window needs to be allocated, there are a few steps to be taken.
if (!startup) {
// Step 1: The area rectangle where the window should fit in is defined.
GdkRectangle area_rectangle;
area_rectangle.x = 0;
area_rectangle.y = 0;
area_rectangle.width = 0;
area_rectangle.height = 0;
{
guint width, height;
gtk_layout_get_size (GTK_LAYOUT (layout), &width, &height);
area_rectangle.width = width;
area_rectangle.height = height;
}
// Step 2: An available region is made of that whole area.
GdkRegion *available_region = gdk_region_rectangle(&area_rectangle);
// Step 3: The regions of each of the open windows is substracted from the available region.
for (unsigned int i = 0; i < settings->session.open_floating_windows.size(); i++) {
FloatingWindow * floating_window = (FloatingWindow *) settings->session.open_floating_windows[i];
GdkRectangle rectangle = floating_window->rectangle_get();
GdkRegion *region = gdk_region_rectangle(&rectangle);
gdk_region_subtract(available_region, region);
gdk_region_destroy(region);
}
// Step 4: The rectangles that the area region consists of are requested,
// and the biggest suitable rectangle is chosen for the window.
// A rectangle is considered suitable if it has at least 10% of the width, and 10% of the height of the area rectangle.
GdkRectangle *gdk_rectangles = NULL;
gint rectangle_count = 0;
gdk_region_get_rectangles(available_region, &gdk_rectangles, &rectangle_count);
for (int i = 0; i < rectangle_count; ++i) {
GdkRectangle & rectangle = gdk_rectangles[i];
if (rectangle.width >= (area_rectangle.width / 10)) {
if (rectangle.height >= (area_rectangle.height / 10)) {
if ((rectangle.width * rectangle.height) > (my_gdk_rectangle.width * my_gdk_rectangle.height)) {
my_gdk_rectangle = rectangle;
}
}
}
}
g_free(gdk_rectangles);
// Step 5: The available region is destroyed.
gdk_region_destroy(available_region);
// Step 6: If no area big enough is found, then the window that takes most space in the area is chosen,
// the longest side is halved, and the new window is put in that freed area.
if ((my_gdk_rectangle.width == 0) || (my_gdk_rectangle.height == 0)) {
FloatingWindow * resize_window_pointer = NULL;
int largest_size = 0;
for (unsigned int i = 0; i < settings->session.open_floating_windows.size(); i++) {
FloatingWindow *floating_window = (FloatingWindow *) settings->session.open_floating_windows[i];
GdkRectangle rectangle = floating_window->rectangle_get ();
int size = rectangle.width * rectangle.height;
if (size > largest_size) {
resize_window_pointer = floating_window;
largest_size = size;
}
}
if (resize_window_pointer) {
GdkRectangle resize_window_rectangle = resize_window_pointer->rectangle_get();
my_gdk_rectangle = resize_window_pointer->rectangle_get();
if (resize_window_rectangle.width > resize_window_rectangle.height) {
resize_window_rectangle.width /= 2;
my_gdk_rectangle.width /= 2;
my_gdk_rectangle.x += resize_window_rectangle.width;
} else {
resize_window_rectangle.height /= 2;
my_gdk_rectangle.height /= 2;
my_gdk_rectangle.y += resize_window_rectangle.height;
}
resize_window_pointer->rectangle_set (resize_window_rectangle);
}
}
}
// Add the window to the layout and set its position and size.
gtk_layout_put (GTK_LAYOUT (layout), vbox_window, my_gdk_rectangle.x, my_gdk_rectangle.y);
rectangle_set (my_gdk_rectangle);
// Store a pointer to this window in the Session.
settings->session.open_floating_windows.push_back(gpointer (this));
}
void
gnc_item_edit_show_popup (GncItemEdit *item_edit)
{
GtkToggleButton *toggle;
GtkAdjustment *vadj, *hadj;
GtkAllocation alloc;
GnucashSheet *sheet;
gint x, y, w, h;
gint y_offset, x_offset;
gint popup_x, popup_y;
gint popup_w = -1, popup_h = -1;
gint popup_max_width, popup_max_height;
gint view_width, view_height;
gint down_height, up_height;
gint sheet_width;
g_return_if_fail (item_edit != NULL);
g_return_if_fail (GNC_IS_ITEM_EDIT(item_edit));
if (!item_edit->is_popup)
return;
sheet = item_edit->sheet;
sheet_width = sheet->width;
gtk_widget_get_allocation (GTK_WIDGET (sheet), &alloc);
view_height = alloc.height;
view_width = alloc.width;
vadj = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(sheet));
hadj = gtk_scrollable_get_hadjustment(GTK_SCROLLABLE(sheet));
y_offset = gtk_adjustment_get_value(vadj);
x_offset = gtk_adjustment_get_value(hadj);
gnc_item_edit_get_pixel_coords (item_edit, &x, &y, &w, &h);
popup_x = x;
up_height = y - y_offset;
down_height = view_height - (up_height + h);
popup_max_height = MAX (up_height, down_height);
popup_max_width = sheet_width - popup_x + x_offset; // always pops to the right
if (item_edit->popup_get_height)
popup_h = item_edit->popup_get_height
(item_edit->popup_item, popup_max_height, h,
item_edit->popup_user_data);
if (item_edit->popup_autosize)
popup_w =
item_edit->popup_autosize (item_edit->popup_item,
popup_max_width,
item_edit->popup_user_data);
else
popup_w = 0;
// Adjust the popup_y point based on popping above or below
if (up_height > down_height)
popup_y = y - popup_h;
else
popup_y = y + h;
if (!gtk_widget_get_parent (item_edit->popup_item))
gtk_layout_put (GTK_LAYOUT(sheet), item_edit->popup_item, popup_x, popup_y);
gtk_widget_set_size_request (item_edit->popup_item, popup_w - 1, popup_h);
toggle = GTK_TOGGLE_BUTTON(item_edit->popup_toggle.tbutton);
if (!gtk_toggle_button_get_active (toggle))
{
block_toggle_signals (item_edit);
gtk_toggle_button_set_active (toggle, TRUE);
unblock_toggle_signals (item_edit);
}
// set the popup arrow direction up
item_edit->popup_toggle.arrow_down = FALSE;
if (item_edit->popup_set_focus)
item_edit->popup_set_focus (item_edit->popup_item,
item_edit->popup_user_data);
if (item_edit->popup_post_show)
item_edit->popup_post_show (item_edit->popup_item,
item_edit->popup_user_data);
if (item_edit->popup_get_width)
{
int popup_width;
popup_width = item_edit->popup_get_width
(item_edit->popup_item,
item_edit->popup_user_data);
if (popup_width > popup_w)
popup_width = popup_w;
if (popup_width > popup_max_width)
{
popup_x -= popup_width - popup_max_width;
popup_x = MAX (0, popup_x);
}
else
popup_x = x;
gtk_layout_move (GTK_LAYOUT(sheet), item_edit->popup_item, popup_x, popup_y);
}
}
void vi_list_refresh(struct vi_list_t *list)
{
int width;
int height;
int x;
int y;
int count;
int i;
GtkStyle *style;
GList *child;
/* Clear current item list and empty layout */
while (list->item_list->count)
vi_list_item_free(list_remove_at(list->item_list, 0));
while ((child = gtk_container_get_children(GTK_CONTAINER(list->widget))))
gtk_container_remove(GTK_CONTAINER(list->widget), child->data);
/* Get 'list' widget size */
width = gtk_widget_get_allocated_width(list->widget);
height = gtk_widget_get_allocated_height(list->widget);
list->width = width;
list->height = height;
/* Background color */
GdkColor color;
style = gtk_widget_get_style(list->widget);
color = style->bg[GTK_STATE_NORMAL];
/* Fill it with labels */
x = 0;
y = 0;
count = list->elem_list->count;
for (i = 0; i < count; i++)
{
int last;
struct vi_list_item_t *item;
void *elem;
char str1[MAX_STRING_SIZE];
char str2[MAX_STRING_SIZE];
char *comma;
GtkWidget *label;
GtkWidget *event_box;
PangoAttrList *attrs;
PangoAttribute *size_attr;
GtkRequisition req;
/* Create list item */
item = vi_list_item_create();
/* Get current element */
elem = list_get(list->elem_list, i);
/* Create label */
comma = i < count - 1 ? "," : "";
if (list->get_elem_name)
(*list->get_elem_name)(elem, str1, sizeof str1);
else
snprintf(str1, sizeof str1, "item-%d", i);
snprintf(str2, sizeof str2, "%s%s", str1, comma);
label = gtk_label_new(str2);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
/* Set label font attributes */
attrs = pango_attr_list_new();
size_attr = pango_attr_size_new_absolute(list->text_size << 10);
pango_attr_list_insert(attrs, size_attr);
gtk_label_set_attributes(GTK_LABEL(label), attrs);
/* Get position */
gtk_widget_get_preferred_size(label, &req, NULL);
last = 0;
if (x > 0 && x + req.width >= width)
{
x = 0;
y += req.height;
if (y + 2 * req.height >= height && i < count - 1)
{
snprintf(str1, sizeof str1, "+ %d more", count - i);
gtk_label_set_text(GTK_LABEL(label), str1);
gtk_widget_get_preferred_size(label, &req, NULL);
last = 1;
}
}
/* Create event box */
event_box = gtk_event_box_new();
gtk_widget_modify_bg(event_box, GTK_STATE_NORMAL, &color);
gtk_container_add(GTK_CONTAINER(event_box), label);
gtk_widget_add_events(event_box, GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK);
/* Events for event box */
g_signal_connect(G_OBJECT(event_box), "enter-notify-event",
G_CALLBACK(vi_list_item_enter_notify_event), item);
g_signal_connect(G_OBJECT(event_box), "leave-notify-event",
G_CALLBACK(vi_list_item_leave_notify_event), item);
if (last)
g_signal_connect(G_OBJECT(event_box), "button-press-event",
G_CALLBACK(vi_list_item_more_press_event), item);
else
g_signal_connect(G_OBJECT(event_box), "button-press-event",
G_CALLBACK(vi_list_item_button_press_event), item);
/* Insert event box in 'list' layout */
gtk_layout_put(GTK_LAYOUT(list->widget), event_box, x, y);
/* Initialize item */
item->list = list;
item->elem = elem;
item->event_box = event_box;
item->label = label;
list_add(list->item_list, item);
/* Advance */
x += req.width + 5;
if (last)
break;
}
/* Show all new widgets */
gtk_widget_show_all(list->widget);
gtk_container_check_resize(GTK_CONTAINER(list->widget));
}
gboolean yatla_layout_load_layout (YatlaLayout* self, YatlaSidebar* sidebar, const gchar* list_name) {
gboolean result = FALSE;
Block4Data* _data4_;
YatlaSidebar* _tmp0_ = NULL;
YatlaSidebar* _tmp1_ = NULL;
const gchar* _tmp2_ = NULL;
gchar* _tmp3_ = NULL;
const gchar* _tmp4_ = NULL;
gchar* _tmp5_ = NULL;
GtkBox* _tmp6_ = NULL;
const gchar* _tmp7_ = NULL;
GtkLabel* _tmp8_ = NULL;
GtkLabel* _tmp9_ = NULL;
GtkLabel* _tmp10_ = NULL;
GtkLabel* _tmp11_ = NULL;
const gchar* _tmp12_ = NULL;
gchar* _tmp13_ = NULL;
gchar* _tmp14_ = NULL;
GtkBox* _tmp15_ = NULL;
GtkLabel* _tmp16_ = NULL;
GtkBox* _tmp17_ = NULL;
GtkEntry* _tmp18_ = NULL;
GtkEntry* _tmp19_ = NULL;
GtkEntry* _tmp20_ = NULL;
GtkBox* _tmp21_ = NULL;
GtkEntry* _tmp22_ = NULL;
GtkBox* _tmp23_ = NULL;
gint list_index = 0;
YatlaSidebar* _tmp24_ = NULL;
GList* _tmp25_ = NULL;
gint task_index = 0;
guint the_longest_task = 0U;
GtkBox* _tmp122_ = NULL;
GtkBox* _tmp123_ = NULL;
GtkBox* _tmp124_ = NULL;
guint _tmp125_ = 0U;
GeeTreeMap* _tmp126_ = NULL;
GeeCollection* _tmp127_ = NULL;
GeeCollection* _tmp128_ = NULL;
GeeCollection* _tmp129_ = NULL;
gint _tmp130_ = 0;
gint _tmp131_ = 0;
GtkEntry* _tmp132_ = NULL;
GeeMapIterator* map_iterator = NULL;
GeeTreeMap* _tmp133_ = NULL;
GeeMapIterator* _tmp134_ = NULL;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (sidebar != NULL, FALSE);
g_return_val_if_fail (list_name != NULL, FALSE);
_data4_ = g_slice_new0 (Block4Data);
_data4_->_ref_count_ = 1;
_data4_->self = g_object_ref (self);
_tmp0_ = sidebar;
_tmp1_ = _g_object_ref0 (_tmp0_);
_g_object_unref0 (_data4_->sidebar);
_data4_->sidebar = _tmp1_;
_tmp2_ = list_name;
_tmp3_ = g_strdup (_tmp2_);
_g_free0 (_data4_->list_name);
_data4_->list_name = _tmp3_;
_tmp4_ = _data4_->list_name;
_tmp5_ = g_strdup (_tmp4_);
_g_free0 (self->_name);
self->_name = _tmp5_;
_tmp6_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
g_object_ref_sink (_tmp6_);
_g_object_unref0 (self->_top_box1);
self->_top_box1 = _tmp6_;
_tmp7_ = _data4_->list_name;
_tmp8_ = (GtkLabel*) gtk_label_new (_tmp7_);
g_object_ref_sink (_tmp8_);
_g_object_unref0 (self->_list_name);
self->_list_name = _tmp8_;
_tmp9_ = self->_list_name;
gtk_label_set_use_markup (_tmp9_, TRUE);
_tmp10_ = self->_list_name;
_tmp11_ = self->_list_name;
_tmp12_ = gtk_label_get_text (_tmp11_);
_tmp13_ = g_strdup_printf ("<span font='14'><b>%s</b></span>", _tmp12_);
_tmp14_ = _tmp13_;
gtk_label_set_markup (_tmp10_, _tmp14_);
_g_free0 (_tmp14_);
_tmp15_ = self->_top_box1;
_tmp16_ = self->_list_name;
gtk_box_pack_start (_tmp15_, (GtkWidget*) _tmp16_, TRUE, TRUE, (guint) 0);
_tmp17_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
g_object_ref_sink (_tmp17_);
_g_object_unref0 (self->_top_box2);
self->_top_box2 = _tmp17_;
_tmp18_ = (GtkEntry*) gtk_entry_new ();
g_object_ref_sink (_tmp18_);
_g_object_unref0 (self->new_task_entry);
self->new_task_entry = _tmp18_;
_tmp19_ = self->new_task_entry;
gtk_entry_set_placeholder_text (_tmp19_, "Add new task");
_tmp20_ = self->new_task_entry;
gtk_entry_set_icon_from_stock (_tmp20_, GTK_ENTRY_ICON_SECONDARY, "gtk-edit");
_tmp21_ = self->_top_box2;
_tmp22_ = self->new_task_entry;
gtk_box_pack_start (_tmp21_, (GtkWidget*) _tmp22_, TRUE, TRUE, (guint) 0);
_tmp23_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
g_object_ref_sink (_tmp23_);
_g_object_unref0 (self->_tasks_box);
self->_tasks_box = _tmp23_;
list_index = 0;
_tmp24_ = _data4_->sidebar;
_tmp25_ = _tmp24_->sidebar_list;
{
GList* list_collection = NULL;
GList* list_it = NULL;
list_collection = _tmp25_;
for (list_it = list_collection; list_it != NULL; list_it = list_it->next) {
YatlaList* _tmp26_ = NULL;
YatlaList* list = NULL;
_tmp26_ = _g_object_ref0 ((YatlaList*) list_it->data);
list = _tmp26_;
{
YatlaList* _tmp27_ = NULL;
const gchar* _tmp28_ = NULL;
const gchar* _tmp29_ = NULL;
const gchar* _tmp30_ = NULL;
gint _tmp31_ = 0;
_tmp27_ = list;
_tmp28_ = yatla_list_get_name (_tmp27_);
_tmp29_ = _tmp28_;
_tmp30_ = _data4_->list_name;
if (g_strcmp0 (_tmp29_, _tmp30_) == 0) {
_g_object_unref0 (list);
break;
}
_tmp31_ = list_index;
list_index = _tmp31_ + 1;
_g_object_unref0 (list);
}
}
}
task_index = 0;
the_longest_task = (guint) 0;
while (TRUE) {
Block5Data* _data5_;
gint _tmp32_ = 0;
YatlaSidebar* _tmp33_ = NULL;
GList* _tmp34_ = NULL;
gint _tmp35_ = 0;
gconstpointer _tmp36_ = NULL;
guint _tmp37_ = 0U;
guint _tmp38_ = 0U;
gint task_id = 0;
YatlaSidebar* _tmp39_ = NULL;
GList* _tmp40_ = NULL;
gint _tmp41_ = 0;
gconstpointer _tmp42_ = NULL;
GList* _tmp43_ = NULL;
gint _tmp44_ = 0;
gconstpointer _tmp45_ = NULL;
gint _tmp46_ = 0;
gint _tmp47_ = 0;
gchar* task_name = NULL;
YatlaSidebar* _tmp48_ = NULL;
GList* _tmp49_ = NULL;
gint _tmp50_ = 0;
gconstpointer _tmp51_ = NULL;
GList* _tmp52_ = NULL;
gint _tmp53_ = 0;
gconstpointer _tmp54_ = NULL;
const gchar* _tmp55_ = NULL;
const gchar* _tmp56_ = NULL;
gchar* _tmp57_ = NULL;
YatlaSidebar* _tmp58_ = NULL;
GList* _tmp59_ = NULL;
gint _tmp60_ = 0;
gconstpointer _tmp61_ = NULL;
GList* _tmp62_ = NULL;
gint _tmp63_ = 0;
gconstpointer _tmp64_ = NULL;
const gchar* _tmp65_ = NULL;
const gchar* _tmp66_ = NULL;
gchar* _tmp67_ = NULL;
GDateTime* task_date = NULL;
YatlaSidebar* _tmp68_ = NULL;
GList* _tmp69_ = NULL;
gint _tmp70_ = 0;
gconstpointer _tmp71_ = NULL;
GList* _tmp72_ = NULL;
gint _tmp73_ = 0;
gconstpointer _tmp74_ = NULL;
GDateTime* _tmp75_ = NULL;
GDateTime* _tmp76_ = NULL;
gboolean task_is_done = FALSE;
YatlaSidebar* _tmp87_ = NULL;
GList* _tmp88_ = NULL;
gint _tmp89_ = 0;
gconstpointer _tmp90_ = NULL;
GList* _tmp91_ = NULL;
gint _tmp92_ = 0;
gconstpointer _tmp93_ = NULL;
gboolean _tmp94_ = FALSE;
gboolean _tmp95_ = FALSE;
YatlaTask* task = NULL;
const gchar* _tmp96_ = NULL;
const gchar* _tmp97_ = NULL;
GDateTime* _tmp98_ = NULL;
gboolean _tmp99_ = FALSE;
YatlaTask* _tmp100_ = NULL;
YatlaTask* _tmp101_ = NULL;
gint _tmp102_ = 0;
const gchar* _tmp103_ = NULL;
gint _tmp104_ = 0;
gint _tmp105_ = 0;
guint _tmp106_ = 0U;
GtkCheckButton* checkBox = NULL;
const gchar* _tmp110_ = NULL;
GtkCheckButton* _tmp111_ = NULL;
GtkCheckButton* _tmp112_ = NULL;
gboolean _tmp113_ = FALSE;
GtkCheckButton* _tmp114_ = NULL;
GtkCheckButton* _tmp115_ = NULL;
GeeTreeMap* _tmp116_ = NULL;
YatlaTask* _tmp117_ = NULL;
GtkCheckButton* _tmp118_ = NULL;
GtkBox* _tmp119_ = NULL;
GtkCheckButton* _tmp120_ = NULL;
gint _tmp121_ = 0;
_data5_ = g_slice_new0 (Block5Data);
_data5_->_ref_count_ = 1;
_data5_->_data4_ = block4_data_ref (_data4_);
_tmp32_ = task_index;
_tmp33_ = _data4_->sidebar;
_tmp34_ = _tmp33_->sidebar_list;
_tmp35_ = list_index;
_tmp36_ = g_list_nth_data (_tmp34_, (guint) _tmp35_);
_tmp37_ = yatla_list_get_size ((YatlaList*) _tmp36_);
_tmp38_ = _tmp37_;
if (!(((guint) _tmp32_) != _tmp38_)) {
block5_data_unref (_data5_);
_data5_ = NULL;
break;
}
_tmp39_ = _data4_->sidebar;
_tmp40_ = _tmp39_->sidebar_list;
_tmp41_ = list_index;
_tmp42_ = g_list_nth_data (_tmp40_, (guint) _tmp41_);
_tmp43_ = ((YatlaList*) _tmp42_)->tasks;
_tmp44_ = task_index;
_tmp45_ = g_list_nth_data (_tmp43_, (guint) _tmp44_);
_tmp46_ = yatla_task_get_id ((YatlaTask*) _tmp45_);
_tmp47_ = _tmp46_;
task_id = _tmp47_;
_tmp48_ = _data4_->sidebar;
_tmp49_ = _tmp48_->sidebar_list;
_tmp50_ = list_index;
_tmp51_ = g_list_nth_data (_tmp49_, (guint) _tmp50_);
_tmp52_ = ((YatlaList*) _tmp51_)->tasks;
_tmp53_ = task_index;
_tmp54_ = g_list_nth_data (_tmp52_, (guint) _tmp53_);
_tmp55_ = yatla_task_get_name ((YatlaTask*) _tmp54_);
_tmp56_ = _tmp55_;
_tmp57_ = g_strdup (_tmp56_);
task_name = _tmp57_;
_tmp58_ = _data4_->sidebar;
_tmp59_ = _tmp58_->sidebar_list;
_tmp60_ = list_index;
_tmp61_ = g_list_nth_data (_tmp59_, (guint) _tmp60_);
_tmp62_ = ((YatlaList*) _tmp61_)->tasks;
_tmp63_ = task_index;
_tmp64_ = g_list_nth_data (_tmp62_, (guint) _tmp63_);
_tmp65_ = yatla_task_get_note ((YatlaTask*) _tmp64_);
_tmp66_ = _tmp65_;
_tmp67_ = g_strdup (_tmp66_);
_data5_->task_note = _tmp67_;
_tmp68_ = _data4_->sidebar;
_tmp69_ = _tmp68_->sidebar_list;
_tmp70_ = list_index;
_tmp71_ = g_list_nth_data (_tmp69_, (guint) _tmp70_);
_tmp72_ = ((YatlaList*) _tmp71_)->tasks;
_tmp73_ = task_index;
_tmp74_ = g_list_nth_data (_tmp72_, (guint) _tmp73_);
_tmp75_ = yatla_task_get_date ((YatlaTask*) _tmp74_);
_tmp76_ = _tmp75_;
if (_tmp76_ != NULL) {
YatlaSidebar* _tmp77_ = NULL;
GList* _tmp78_ = NULL;
gint _tmp79_ = 0;
gconstpointer _tmp80_ = NULL;
GList* _tmp81_ = NULL;
gint _tmp82_ = 0;
gconstpointer _tmp83_ = NULL;
GDateTime* _tmp84_ = NULL;
GDateTime* _tmp85_ = NULL;
GDateTime* _tmp86_ = NULL;
_tmp77_ = _data4_->sidebar;
_tmp78_ = _tmp77_->sidebar_list;
_tmp79_ = list_index;
_tmp80_ = g_list_nth_data (_tmp78_, (guint) _tmp79_);
_tmp81_ = ((YatlaList*) _tmp80_)->tasks;
_tmp82_ = task_index;
_tmp83_ = g_list_nth_data (_tmp81_, (guint) _tmp82_);
_tmp84_ = yatla_task_get_date ((YatlaTask*) _tmp83_);
_tmp85_ = _tmp84_;
_tmp86_ = _g_date_time_ref0 (_tmp85_);
_g_date_time_unref0 (task_date);
task_date = _tmp86_;
} else {
_g_date_time_unref0 (task_date);
task_date = NULL;
}
_tmp87_ = _data4_->sidebar;
_tmp88_ = _tmp87_->sidebar_list;
_tmp89_ = list_index;
_tmp90_ = g_list_nth_data (_tmp88_, (guint) _tmp89_);
_tmp91_ = ((YatlaList*) _tmp90_)->tasks;
_tmp92_ = task_index;
_tmp93_ = g_list_nth_data (_tmp91_, (guint) _tmp92_);
_tmp94_ = yatla_task_get_is_done ((YatlaTask*) _tmp93_);
_tmp95_ = _tmp94_;
task_is_done = _tmp95_;
_tmp96_ = task_name;
_tmp97_ = _data5_->task_note;
_tmp98_ = task_date;
_tmp99_ = task_is_done;
_tmp100_ = yatla_task_new (_tmp96_, _tmp97_, _tmp98_, _tmp99_);
task = _tmp100_;
_tmp101_ = task;
_tmp102_ = task_id;
yatla_task_set_id (_tmp101_, _tmp102_);
_tmp103_ = task_name;
_tmp104_ = strlen (_tmp103_);
_tmp105_ = _tmp104_;
_tmp106_ = the_longest_task;
if (((guint) _tmp105_) > _tmp106_) {
const gchar* _tmp107_ = NULL;
gint _tmp108_ = 0;
gint _tmp109_ = 0;
_tmp107_ = task_name;
_tmp108_ = strlen (_tmp107_);
_tmp109_ = _tmp108_;
the_longest_task = (guint) _tmp109_;
}
_tmp110_ = task_name;
_tmp111_ = (GtkCheckButton*) gtk_check_button_new_with_label (_tmp110_);
g_object_ref_sink (_tmp111_);
checkBox = _tmp111_;
_tmp112_ = checkBox;
_tmp113_ = task_is_done;
gtk_toggle_button_set_active ((GtkToggleButton*) _tmp112_, _tmp113_);
_tmp114_ = checkBox;
gtk_widget_set_has_tooltip ((GtkWidget*) _tmp114_, TRUE);
_tmp115_ = checkBox;
g_signal_connect_data ((GtkWidget*) _tmp115_, "query-tooltip", (GCallback) ____lambda4__gtk_widget_query_tooltip, block5_data_ref (_data5_), (GClosureNotify) block5_data_unref, 0);
_tmp116_ = self->tasks;
_tmp117_ = task;
_tmp118_ = checkBox;
gee_abstract_map_set ((GeeAbstractMap*) _tmp116_, _tmp117_, _tmp118_);
_tmp119_ = self->_tasks_box;
_tmp120_ = checkBox;
gtk_box_pack_start (_tmp119_, (GtkWidget*) _tmp120_, TRUE, TRUE, (guint) 0);
_tmp121_ = task_index;
task_index = _tmp121_ + 1;
_g_object_unref0 (checkBox);
_g_object_unref0 (task);
_g_date_time_unref0 (task_date);
_g_free0 (task_name);
block5_data_unref (_data5_);
_data5_ = NULL;
}
_tmp122_ = self->_top_box1;
gtk_layout_put ((GtkLayout*) self, (GtkWidget*) _tmp122_, 25, 20);
_tmp123_ = self->_top_box2;
gtk_layout_put ((GtkLayout*) self, (GtkWidget*) _tmp123_, 20, 40);
_tmp124_ = self->_tasks_box;
gtk_layout_put ((GtkLayout*) self, (GtkWidget*) _tmp124_, 20, 100);
_tmp125_ = the_longest_task;
g_object_set ((GtkLayout*) self, "width", 65 + (_tmp125_ * 7), NULL);
_tmp126_ = self->tasks;
_tmp127_ = gee_abstract_map_get_values ((GeeMap*) _tmp126_);
_tmp128_ = _tmp127_;
_tmp129_ = _tmp128_;
_tmp130_ = gee_collection_get_size (_tmp129_);
_tmp131_ = _tmp130_;
g_object_set ((GtkLayout*) self, "height", (guint) (100 + (_tmp131_ * 30)), NULL);
_g_object_unref0 (_tmp129_);
gtk_widget_show_all ((GtkWidget*) self);
_tmp132_ = self->new_task_entry;
g_signal_connect_data (_tmp132_, "icon-press", (GCallback) ___lambda5__gtk_entry_icon_press, block4_data_ref (_data4_), (GClosureNotify) block4_data_unref, 0);
_tmp133_ = self->tasks;
_tmp134_ = gee_abstract_map_map_iterator ((GeeAbstractMap*) _tmp133_);
map_iterator = _tmp134_;
while (TRUE) {
Block6Data* _data6_;
GeeMapIterator* _tmp135_ = NULL;
gboolean _tmp136_ = FALSE;
GeeMapIterator* _tmp137_ = NULL;
gpointer _tmp138_ = NULL;
GeeMapIterator* _tmp139_ = NULL;
gpointer _tmp140_ = NULL;
GtkCheckButton* _tmp141_ = NULL;
_data6_ = g_slice_new0 (Block6Data);
_data6_->_ref_count_ = 1;
_data6_->_data4_ = block4_data_ref (_data4_);
_tmp135_ = map_iterator;
_tmp136_ = gee_map_iterator_next (_tmp135_);
if (!_tmp136_) {
block6_data_unref (_data6_);
_data6_ = NULL;
break;
}
_tmp137_ = map_iterator;
_tmp138_ = gee_map_iterator_get_value (_tmp137_);
_data6_->checkBox = (GtkCheckButton*) _tmp138_;
_tmp139_ = map_iterator;
_tmp140_ = gee_map_iterator_get_key (_tmp139_);
_data6_->task = (YatlaTask*) _tmp140_;
_tmp141_ = _data6_->checkBox;
g_signal_connect_data ((GObject*) _tmp141_, "notify::active", (GCallback) ____lambda11__g_object_notify, block6_data_ref (_data6_), (GClosureNotify) block6_data_unref, 0);
block6_data_unref (_data6_);
_data6_ = NULL;
}
result = TRUE;
_g_object_unref0 (map_iterator);
block4_data_unref (_data4_);
_data4_ = NULL;
return result;
}
int load_host_buttons(topview * t, Agraph_t * g, glCompSet * s)
{
GtkLayout *layout;
int btncount = 0;
int i = 0;
char *str;
char hostbtncaption[50];
char hostbtnregex[50];
char hostbtncolorR[50];
char hostbtncolorG[50];
char hostbtncolorB[50];
char hostbtncolorA[50];
int X = 10;
int Y = 25;
GdkColor color;
glCompPanel *p;
glCompButton *b;
layout =
(GtkLayout *) glade_xml_get_widget(xml, "frmHostSelectionFixed");
str = '\0';
str = agget(g, "hostbtncount");
if (str)
btncount = atoi(str);
// Graph [hostbtncaption1="AT&T",hostbtnregex1="*.ATT*",hostbtncolorR1="1",hostbtncolorG1="0",hostbtncolorB1="0",hostbtncolorA1="1"];
t->TopviewData->hostregex = N_GNEW(btncount, char *);
t->TopviewData->gtkhostbtn = N_GNEW(btncount, GtkButton *);
t->TopviewData->gtkhostcolor = N_GNEW(btncount, GtkColorButton *);
t->TopviewData->gtkhostbtncount = btncount;
if (btncount > 0) {
p = glCompPanelNew(25, 75, 165, 400);
p->data = 2; //data panel
p->color.R = (float) 0.80;
p->color.B = (float) 0.2;
glCompSetAddPanel(s, p);
} else
return 0;
for (i = 0; i < btncount; i++) {
sprintf(hostbtncaption, "hostbtncaption%i", i);
sprintf(hostbtnregex, "hostbtnregex%i", i);
sprintf(hostbtncolorR, "hostbtncolorR%i", i);
sprintf(hostbtncolorG, "hostbtncolorG%i", i);
sprintf(hostbtncolorB, "hostbtncolorB%i", i);
sprintf(hostbtncolorA, "hostbtncolorA%i", i);
agget(g, hostbtncaption),
agget(g, hostbtnregex),
agget(g, hostbtncolorR),
agget(g, hostbtncolorG),
agget(g, hostbtncolorB), agget(g, hostbtncolorA);
t->TopviewData->hostregex[i] = agget(g, hostbtnregex);
b = glCompButtonNew((GLfloat) 5,
(GLfloat) 7 + ((GLfloat) i +
(GLfloat) 1) * (GLfloat) 36,
(GLfloat) 150, (GLfloat) 35, agget(g,
hostbtncaption),
'\0', 0, 0);
b->color.R = (float) atof(agget(g, hostbtncolorR));
b->color.G = (float) atof(agget(g, hostbtncolorG));
b->color.B = (float) atof(agget(g, hostbtncolorB));
b->color.A = (float) 1;
b->panel = p;
b->groupid = -1;
b->callbackfunc = glhost_button_clicked_Slot;
b->data = i;
glCompSetAddButton(s, b);
t->TopviewData->gtkhostbtn[i] = (GtkButton *)
gtk_button_new_with_label(agget(g, hostbtncaption));
g_signal_connect((gpointer) t->TopviewData->gtkhostbtn[i],
"clicked", G_CALLBACK(host_button_clicked_Slot),
(gpointer) i);
color.blue = 65535 * atoi(agget(g, hostbtncolorB));
color.red = 65535 * atoi(agget(g, hostbtncolorR));
color.green = 65535 * atoi(agget(g, hostbtncolorG));
t->TopviewData->gtkhostcolor[i] =
(GtkColorButton *) gtk_color_button_new_with_color(&color);
gtk_color_button_set_alpha((GtkColorButton *) t->TopviewData->
gtkhostbtn[i],
65535 * atoi(agget(g, hostbtncolorA)));
gtk_layout_put(layout, (GtkWidget *) t->TopviewData->gtkhostbtn[i],
X, Y);
gtk_widget_set_size_request((GtkWidget *) t->TopviewData->
gtkhostbtn[i], 200, 35);
gtk_layout_put(layout,
(GtkWidget *) t->TopviewData->gtkhostcolor[i],
X + 225, Y);
gtk_widget_set_size_request((GtkWidget *) t->TopviewData->
gtkhostcolor[i], 40, 35);
gtk_widget_show((GtkWidget *) t->TopviewData->gtkhostbtn[i]);
gtk_widget_show((GtkWidget *) t->TopviewData->gtkhostcolor[i]);
Y = Y + 40;
t->TopviewData->hostactive[i] = 0;
}
p->height = (GLfloat) 15 + (GLfloat) (btncount + 1) * (GLfloat) 36;
for (i = 0; i < btncount; i++) {
prepare_nodes_for_groups(t, t->TopviewData, i);
}
return 1;
}
int main(int argc, char **argv){
gtk_init (&argc, &argv);
GtkWidget *p_window;
GdkPixbuf *Pixbuf;
GError *error=NULL;
/* Creation de la fenetre principale de notre application */
p_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(p_window), GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(p_window),"Face Identifier Project");
gtk_window_set_default_size(GTK_WINDOW(p_window),800,500);
Pixbuf = gdk_pixbuf_new_from_file("logo.jpeg",&error);
gtk_window_set_icon(GTK_WINDOW(p_window),Pixbuf);
GdkGeometry hints;
hints.min_width = 800;
hints.max_width = 800;
hints.min_height = 500;
hints.max_height = 500;
gtk_window_set_geometry_hints(
GTK_WINDOW(p_window),
p_window,
&hints,
(GdkWindowHints)(GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));
/* Creation des buttons */
GtkWidget *p_button1= gtk_button_new_with_label("Search");
gtk_widget_set_size_request(p_button1,120,90);
GtkWidget *p_button2= gtk_button_new_with_label("Identify");
gtk_widget_set_size_request(p_button2,120,90);
GtkWidget *p_button3= gtk_button_new_with_label("Add");
gtk_widget_set_size_request(p_button3,120,90);
/* Insertion des boutons */
g_signal_connect (G_OBJECT (p_button1), "clicked", G_CALLBACK (cb_open), NULL);
g_signal_connect (G_OBJECT (p_button2), "clicked", G_CALLBACK (face_detection), NULL);
g_signal_connect (G_OBJECT (p_button3), "clicked", G_CALLBACK (cb_add), NULL);
layout = gtk_layout_new(NULL, NULL);
GtkWidget *backgrd = gtk_image_new_from_file("backgroundUI.jpg");
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
GtkWidget *scrollbar = gtk_scrolled_window_new(NULL, NULL);
DIR* FD = opendir ("./DataBase");
struct dirent* in_file;
GtkWidget *ImgScr;
GdkPixbuf *Pbx;
GtkWidget *Label;
if (NULL != FD)
{
while ((in_file =readdir(FD)))
{
if (!strcmp (in_file->d_name, "."))
continue;
if (!strcmp (in_file->d_name, ".."))
continue;
Pbx = gdk_pixbuf_new_from_file_at_scale (concat("DataBase/",in_file->d_name),220,150,TRUE,NULL);
ImgScr = gtk_image_new_from_pixbuf(Pbx);
Label = gtk_label_new (remove_after_dot(in_file->d_name));
g_object_unref (Pbx);
gtk_box_pack_start(GTK_BOX(box), ImgScr, FALSE, FALSE, 3);
gtk_box_pack_start(GTK_BOX(box), Label, FALSE, FALSE, 3);
}
(void) closedir (FD);
}
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollbar),GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_widget_set_size_request(scrollbar, 253,398);
gtk_container_add(GTK_CONTAINER(scrollbar), box);
gtk_layout_put(GTK_LAYOUT(layout), backgrd, 0, 0);
gtk_container_add(GTK_CONTAINER(p_window), layout);
gtk_layout_put(GTK_LAYOUT (layout), scrollbar, 548,0);
gtk_layout_put (GTK_LAYOUT (layout), p_button1, 250, 405);
gtk_layout_put (GTK_LAYOUT (layout), p_button2, 100, 405);
gtk_layout_put (GTK_LAYOUT (layout), p_button3, 400, 405);
g_signal_connect(G_OBJECT(p_window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
/* Affichage de la fenetre principale */
gtk_widget_show_all (p_window);
/* Lancement de la boucle principale */
gtk_main ();
return EXIT_SUCCESS;
return 0;
}
static void
create_layout (GtkWidget *vbox)
{
GtkAdjustment *hadjustment, *vadjustment;
GtkLayout *layout;
GtkWidget *layout_widget;
GtkWidget *scrolledwindow;
GtkWidget *button;
gchar buf[16];
gint i, j;
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_SHADOW_IN);
gtk_scrolled_window_set_placement (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_CORNER_TOP_RIGHT);
gtk_box_pack_start (GTK_BOX (vbox), scrolledwindow, TRUE, TRUE, 0);
layout_widget = gtk_layout_new (NULL, NULL);
layout = GTK_LAYOUT (layout_widget);
gtk_container_add (GTK_CONTAINER (scrolledwindow), layout_widget);
/* We set step sizes here since GtkLayout does not set
* them itself.
*/
hadjustment = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (layout));
vadjustment = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (layout));
gtk_adjustment_set_step_increment (hadjustment, 10.0);
gtk_adjustment_set_step_increment (vadjustment, 10.0);
gtk_scrollable_set_hadjustment (GTK_SCROLLABLE (layout), hadjustment);
gtk_scrollable_set_vadjustment (GTK_SCROLLABLE (layout), vadjustment);
gtk_widget_set_events (layout_widget, GDK_EXPOSURE_MASK);
g_signal_connect (layout, "draw",
G_CALLBACK (layout_draw_handler),
NULL);
gtk_layout_set_size (layout, 1600, 128000);
for (i = 0 ; i < 16 ; i++)
for (j = 0 ; j < 16 ; j++)
{
g_snprintf (buf, sizeof (buf), "Button %d, %d", i, j);
if ((i + j) % 2)
button = gtk_button_new_with_label (buf);
else
button = gtk_label_new (buf);
gtk_layout_put (layout, button, j * 100, i * 100);
}
for (i = 16; i < 1280; i++)
{
g_snprintf (buf, sizeof (buf), "Button %d, %d", i, 0);
if (i % 2)
button = gtk_button_new_with_label (buf);
else
button = gtk_label_new (buf);
gtk_layout_put (layout, button, 0, i * 100);
}
layout_timeout = g_timeout_add (1000, scroll_layout, layout);
}
