static void
infinoted_plugin_manager_set_directory(InfinotedPluginManager* manager,
InfdDirectory* directory)
{
InfinotedPluginManagerPrivate* priv;
priv = INFINOTED_PLUGIN_MANAGER_PRIVATE(manager);
/* Directory can only be changed while no plugins are loaded. */
g_assert(priv->plugins == NULL);
if(priv->directory != NULL)
{
inf_signal_handlers_disconnect_by_func(
G_OBJECT(priv->directory),
G_CALLBACK(infinoted_plugin_manager_connection_added_cb),
manager
);
inf_signal_handlers_disconnect_by_func(
G_OBJECT(priv->directory),
G_CALLBACK(infinoted_plugin_manager_connection_removed_cb),
manager
);
inf_signal_handlers_disconnect_by_func(
G_OBJECT(priv->directory),
G_CALLBACK(infinoted_plugin_manager_subscribe_session_cb),
manager
);
inf_signal_handlers_disconnect_by_func(
G_OBJECT(priv->directory),
G_CALLBACK(infinoted_plugin_manager_unsubscribe_session_cb),
manager
);
g_object_unref(priv->directory);
}
priv->directory = directory;
if(directory != NULL)
{
g_object_ref(priv->directory);
g_signal_connect_after(
G_OBJECT(directory),
"connection-added",
G_CALLBACK(infinoted_plugin_manager_connection_added_cb),
manager
);
g_signal_connect_after(
G_OBJECT(directory),
"connection-removed",
G_CALLBACK(infinoted_plugin_manager_connection_removed_cb),
manager
);
g_signal_connect_after(
G_OBJECT(directory),
"subscribe-session",
G_CALLBACK(infinoted_plugin_manager_subscribe_session_cb),
manager
);
g_signal_connect_after(
G_OBJECT(directory),
"unsubscribe-session",
G_CALLBACK(infinoted_plugin_manager_unsubscribe_session_cb),
manager
);
}
g_object_notify(G_OBJECT(manager), "directory");
}
WAttTextGtk::WAttTextGtk(GtkWidget* wa_parent_wid, void* wa_parent_ctx,
ldh_tSesContext wa_ldhses, pwr_sAttrRef wa_aref, int wa_editmode,
pwr_tStatus* status)
: WAttText(wa_parent_ctx, wa_ldhses, wa_aref, wa_editmode, status),
parent_wid(wa_parent_wid), toplevel(0), init(1)
{
int sts;
int size;
char* namep;
if (EVEN(*status))
return;
sts = ldh_AttrRefToName(ldhses, &aref, ldh_eName_Hierarchy, &namep, &size);
if (EVEN(sts)) {
*status = sts;
return;
}
toplevel = (GtkWidget*)g_object_new(GTK_TYPE_WINDOW, "default-height", 700,
"default-width", 800, "title", CoWowGtk::convert_utf8(namep), NULL);
g_signal_connect(toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect(toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect(
toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);
CoWowGtk::SetWindowIcon(toplevel);
// Menu
// Accelerators
GtkAccelGroup* accel_g
= (GtkAccelGroup*)g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar* menu_bar = (GtkMenuBar*)g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File entry
GtkWidget* file_close
= gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
GtkWidget* file_save
= gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, accel_g);
g_signal_connect(file_save, "activate", G_CALLBACK(activate_save), this);
GtkWidget* file_saveandclose
= gtk_menu_item_new_with_mnemonic("S_ave and close");
g_signal_connect(
file_saveandclose, "activate", G_CALLBACK(activate_saveandclose), this);
gtk_widget_add_accelerator(file_saveandclose, "activate", accel_g, 't',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkMenu* file_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_save);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_saveandclose);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget* file = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Edit entry
GtkWidget* edit_copy
= gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY, accel_g);
g_signal_connect(edit_copy, "activate", G_CALLBACK(activate_copy), this);
GtkWidget* edit_cut
= gtk_image_menu_item_new_from_stock(GTK_STOCK_CUT, accel_g);
g_signal_connect(edit_cut, "activate", G_CALLBACK(activate_cut), this);
GtkWidget* edit_paste
= gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE, accel_g);
g_signal_connect(edit_paste, "activate", G_CALLBACK(activate_paste), this);
GtkMenu* edit_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_copy);
gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_cut);
gtk_menu_shell_append(GTK_MENU_SHELL(edit_menu), edit_paste);
GtkWidget* edit = gtk_menu_item_new_with_mnemonic("_Edit");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), edit);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(edit), GTK_WIDGET(edit_menu));
// Help entry
GtkWidget* help_help
= gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
GtkMenu* help_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget* help = gtk_menu_item_new_with_mnemonic("_Help");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
if (((WUtility*)parent_ctx)->utype == wb_eUtility_WNav)
parent_ctx = ((WNav*)parent_ctx)->parent_ctx;
utility = ((WUtility*)parent_ctx)->utype;
textbuffer = gtk_text_buffer_new(NULL);
g_signal_connect_after(
textbuffer, "insert-text", G_CALLBACK(action_text_inserted), this);
g_signal_connect_after(
textbuffer, "changed", G_CALLBACK(action_text_changed), this);
textview = gtk_text_view_new_with_buffer(textbuffer);
GtkWidget* viewport = gtk_viewport_new(NULL, NULL);
GtkWidget* scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(viewport), textview);
gtk_container_add(GTK_CONTAINER(scrolledwindow), viewport);
button_ok = gtk_button_new_with_label("Ok");
gtk_widget_set_size_request(button_ok, 70, 25);
g_signal_connect(button_ok, "clicked", G_CALLBACK(activate_ok), this);
button_apply = gtk_button_new_with_label("Apply");
gtk_widget_set_size_request(button_apply, 70, 25);
g_signal_connect(button_apply, "clicked", G_CALLBACK(activate_apply), this);
button_cancel = gtk_button_new_with_label("Cancel");
gtk_widget_set_size_request(button_cancel, 70, 25);
g_signal_connect(button_cancel, "clicked", G_CALLBACK(activate_cancel), this);
GtkWidget* hboxbuttons = gtk_hbox_new(TRUE, 40);
gtk_box_pack_start(GTK_BOX(hboxbuttons), button_ok, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hboxbuttons), button_apply, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hboxbuttons), button_cancel, FALSE, FALSE, 0);
msg_label = gtk_label_new("");
gtk_widget_set_size_request(msg_label, -1, 25);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hboxbuttons, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), msg_label, FALSE, FALSE, 5);
gtk_container_add(GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all(toplevel);
if (utility == wb_eUtility_Wtt) {
((Wtt*)parent_ctx)
->register_utility((void*)this, wb_eUtility_AttrTextEditor);
}
char* value;
ldh_sAttrRefInfo ainfo;
sts = ldh_GetAttrRefInfo(ldhses, &aref, &ainfo);
if (EVEN(sts)) {
*status = sts;
return;
}
char* s = strchr(namep, '.');
if (!s)
return;
strncpy(aname, s + 1, sizeof(aname));
sts = ldh_GetObjectPar(
ldhses, aref.Objid, "DevBody", aname, (char**)&value, &size);
if (EVEN(sts)) {
*status = sts;
return;
}
input_max_length = ainfo.size - 1;
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter(textbuffer, &start_iter);
gtk_text_buffer_get_end_iter(textbuffer, &end_iter);
gtk_text_buffer_delete(textbuffer, &start_iter, &end_iter);
gtk_text_buffer_get_start_iter(textbuffer, &start_iter);
char* textutf8 = g_convert(value, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
gtk_text_buffer_insert(textbuffer, &start_iter, textutf8, -1);
g_free(textutf8);
free(value);
if (!editmode) {
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview), FALSE);
}
wow = new CoWowGtk(toplevel);
init = 0;
}
static void
GDict_dlg_create (const char * search)
{
GtkWidget * vbox;
GtkWidget * hbox;
GtkWidget * button;
GtkWidget * scrolled;
GtkWidget * close;
GtkWidget * gtk_entry;
// create the toplevel dialog
gdict_dlg = gnome_dialog_new ("AbiWord Dictionary",
GNOME_STOCK_BUTTON_CLOSE, NULL);
gtk_window_set_modal (GTK_WINDOW(gdict_dlg), false);
gtk_widget_set_usize (gdict_dlg, 450, 300);
// center the dialog and connect focus
XAP_App * pApp = XAP_App::getApp ();
XAP_UnixFrame * pFrame = static_cast<XAP_UnixFrame*>(pApp->getLastFocussedFrame ());
GtkWidget * parent = pFrame->getTopLevelWindow();
centerDialog(parent, gdict_dlg);
close = GTK_WIDGET (g_list_last (GNOME_DIALOG (gdict_dlg)->buttons)->data);
vbox = GNOME_DIALOG(gdict_dlg)->vbox;
hbox = gtk_hbox_new (FALSE, GNOME_PAD_SMALL);
gtk_container_set_border_width (GTK_CONTAINER (hbox), GNOME_PAD_SMALL);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Look Up");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gdict_entry = gnome_entry_new(NULL);
gtk_entry = gnome_entry_gtk_entry(GNOME_ENTRY(gdict_entry));
gtk_box_pack_start (GTK_BOX (hbox), gdict_entry, TRUE, TRUE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_container_set_border_width (GTK_CONTAINER (scrolled), GNOME_PAD_SMALL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0);
gdict_defbox = gdict_defbox_new ();
gtk_widget_show (gdict_defbox);
gtk_container_add (GTK_CONTAINER (scrolled), gdict_defbox);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (lookup_button_cb), gdict_defbox);
g_signal_connect (G_OBJECT (gtk_entry), "activate",
G_CALLBACK (entry_activate_cb), gdict_defbox);
#if 0
g_signal_connect (G_OBJECT (gtk_entry), "changed",
G_CALLBACK (entry_activate_cb), gdict_defbox);
#endif
g_signal_connect (G_OBJECT (gdict_dlg),
"close",
G_CALLBACK(close_cb),
(gpointer)0);
g_signal_connect (G_OBJECT (close),
"clicked",
G_CALLBACK(close_cb),
(gpointer)0);
g_signal_connect_after(G_OBJECT(gdict_dlg),
"destroy",
NULL,
NULL);
gtk_widget_show_all (gdict_dlg);
}
bool wxComboBox::Create( wxWindow *parent, wxWindowID id, const wxString& value,
const wxPoint& pos, const wxSize& size,
int n, const wxString choices[],
long style, const wxValidator& validator,
const wxString& name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxComboBox creation failed") );
return false;
}
if (HasFlag(wxCB_SORT))
m_strings = new wxGtkCollatedArrayString();
GTKCreateComboBoxWidget();
if (HasFlag(wxBORDER_NONE))
{
// Doesn't seem to work
// g_object_set (m_widget, "has-frame", FALSE, NULL);
}
GtkEntry * const entry = GetEntry();
if ( entry )
{
// Set it up to trigger default item on enter key press
gtk_entry_set_activates_default( entry,
!HasFlag(wxTE_PROCESS_ENTER) );
gtk_editable_set_editable(GTK_EDITABLE(entry), true);
}
Append(n, choices);
m_parent->DoAddChild( this );
if ( entry )
m_focusWidget = GTK_WIDGET( entry );
PostCreation(size);
if ( entry )
{
if (style & wxCB_READONLY)
{
// this will assert and do nothing if the value is not in our list
// of strings which is the desired behaviour (for consistency with
// wxMSW and also because it doesn't make sense to have a string
// which is not a possible choice in a read-only combobox)
SetStringSelection(value);
gtk_editable_set_editable(GTK_EDITABLE(entry), false);
}
else // editable combobox
{
// any value is accepted, even if it's not in our list
gtk_entry_set_text( entry, wxGTK_CONV(value) );
}
g_signal_connect_after (entry, "changed",
G_CALLBACK (gtkcombobox_text_changed_callback), this);
GTKConnectInsertTextSignal(entry);
GTKConnectClipboardSignals(GTK_WIDGET(entry));
}
g_signal_connect_after (m_widget, "changed",
G_CALLBACK (gtkcombobox_changed_callback), this);
#ifndef __WXGTK3__
if ( !gtk_check_version(2,10,0) )
#endif
{
g_signal_connect (m_widget, "notify::popup-shown",
G_CALLBACK (gtkcombobox_popupshown_callback), this);
}
return true;
}
void buildMainGui(void)
{
GtkWidget* vbox;
GtkWidget* menuitem;
GtkWidget* menu;
GtkWidget* toolbar;
GtkToolItem* toolbutton;
GtkAccelGroup* accgroup;
GtkWidget* image;
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title((GtkWindow*)window,"Manpage Editor");
gtk_window_set_default_size((GtkWindow*)window,windowWidth,windowHeight);
if(windowX!=-1 && windowY!=-1)
gtk_window_move((GtkWindow *)window,windowX,windowY);
g_signal_connect(G_OBJECT(window),"delete-event",G_CALLBACK(doShutdown),NULL);
accgroup=gtk_accel_group_new();
gtk_window_add_accel_group((GtkWindow*)window,accgroup);
notebook=(GtkNotebook*)gtk_notebook_new();
gtk_notebook_set_scrollable(notebook,true);
g_signal_connect(G_OBJECT(notebook),"page-reordered",G_CALLBACK(reorderDirty),NULL);
vbox=creatNewBox(NEWVBOX,false,0);
menubar=gtk_menu_bar_new();
toolbar=gtk_toolbar_new();
gtk_box_pack_start(GTK_BOX(vbox),(GtkWidget*)menubar,false,true,0);
gtk_box_pack_start(GTK_BOX(vbox),(GtkWidget*)toolbar,false,true,0);
gtk_box_pack_start(GTK_BOX(vbox),(GtkWidget*)notebook,true,true,0);
//toolbar
//new
newButton=makeNewToolItem(GTK_STOCK_NEW,"New");
gtk_toolbar_insert((GtkToolbar*)toolbar,newButton,-1);
g_signal_connect(G_OBJECT(newButton),"clicked",G_CALLBACK(newSection),NULL);
gtk_widget_set_tooltip_text((GtkWidget*)newButton,"New File");
//save
saveButton=makeNewToolItem(GTK_STOCK_SAVE,"Save");
gtk_toolbar_insert((GtkToolbar*)toolbar,saveButton,-1);
g_signal_connect(G_OBJECT(saveButton),"clicked",G_CALLBACK(saveManpage),NULL);
gtk_widget_set_tooltip_text((GtkWidget*)saveButton,"Save File");
gtk_toolbar_insert((GtkToolbar*)toolbar,gtk_separator_tool_item_new(),-1);
//edit buttons
//cut
toolbutton=makeNewToolItem(GTK_STOCK_CUT,"Cut");
gtk_toolbar_insert((GtkToolbar*)toolbar,toolbutton,-1);
g_signal_connect(G_OBJECT(toolbutton),"clicked",G_CALLBACK(cutToClip),NULL);
gtk_widget_set_tooltip_text((GtkWidget*)toolbutton,"Cut");
//copy
toolbutton=makeNewToolItem(GTK_STOCK_COPY,"Copy");
gtk_toolbar_insert((GtkToolbar*)toolbar,toolbutton,-1);
g_signal_connect(G_OBJECT(toolbutton),"clicked",G_CALLBACK(copyToClip),NULL);
gtk_widget_set_tooltip_text((GtkWidget*)toolbutton,"Copy");
//paste
toolbutton=makeNewToolItem(GTK_STOCK_PASTE,"Paste");
gtk_toolbar_insert((GtkToolbar*)toolbar,toolbutton,-1);
g_signal_connect(G_OBJECT(toolbutton),"clicked",G_CALLBACK(pasteFromClip),NULL);
gtk_widget_set_tooltip_text((GtkWidget*)toolbutton,"Paste");
gtk_toolbar_insert((GtkToolbar*)toolbar,gtk_separator_tool_item_new(),-1);
//undo
undoButton=makeNewToolItem(GTK_STOCK_UNDO,"Undo");
gtk_toolbar_insert((GtkToolbar*)toolbar,undoButton,-1);
g_signal_connect(G_OBJECT(undoButton),"clicked",G_CALLBACK(undo),NULL);
gtk_widget_set_tooltip_text((GtkWidget*)undoButton,"Undo");
//redo
redoButton=makeNewToolItem(GTK_STOCK_REDO,"Redo");
gtk_toolbar_insert((GtkToolbar*)toolbar,redoButton,-1);
g_signal_connect(G_OBJECT(redoButton),"clicked",G_CALLBACK(redo),NULL);
gtk_widget_set_tooltip_text((GtkWidget*)redoButton,"Redo");
gtk_toolbar_insert((GtkToolbar*)toolbar,gtk_separator_tool_item_new(),-1);
//find
toolbutton=makeNewToolItem(GTK_STOCK_FIND,"Find");
gtk_toolbar_insert((GtkToolbar*)toolbar,toolbutton,-1);
g_signal_connect(G_OBJECT(toolbutton),"clicked",G_CALLBACK(find),NULL);
gtk_widget_set_tooltip_text((GtkWidget*)toolbutton,"Find/Replace");
//livesearch
liveSearchWidget=gtk_entry_new();
toolbutton=gtk_tool_item_new();
gtk_container_add((GtkContainer *)toolbutton,liveSearchWidget);
gtk_toolbar_insert((GtkToolbar*)toolbar,toolbutton,-1);
g_signal_connect_after(G_OBJECT(liveSearchWidget),"key-release-event",G_CALLBACK(doLiveSearch),NULL);
gtk_widget_set_tooltip_text((GtkWidget*)toolbutton,"Live Search");
//menus
//file menu
menufile=gtk_menu_item_new_with_label("File");
menu=gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menufile),menu);
//new
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_New");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_NEW,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(newManpage),NULL);
gtk_widget_add_accelerator((GtkWidget *)menuitem,"activate",accgroup,'N',GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
//newsection
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("New Section");
#else
menuitem=gtk_image_menu_item_new_with_label("New Section");
image=gtk_image_new_from_stock(GTK_STOCK_NEW,GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image((GtkImageMenuItem *)menuitem,image);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(newSection),NULL);
//open
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_Open");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(openManpage),NULL);
gtk_widget_add_accelerator((GtkWidget *)menuitem,"activate",accgroup,'O',GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
menuitem=gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
//open recent menu
menuitem=gtk_menu_item_new_with_mnemonic("_Recent");
setupRecent((GtkMenuItem*)menuitem);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
menuitem=gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
//newtemplate
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_label("New From Template");
#else
menuitem=gtk_image_menu_item_new_with_label("New From Template");
image=gtk_image_new_from_stock(GTK_STOCK_NEW,GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image((GtkImageMenuItem *)menuitem,image);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(openManpage),(void*)1);
//new editor
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_label("New Editor");
#else
menuitem=gtk_image_menu_item_new_with_label("New Editor");
image=gtk_image_new_from_stock(GTK_STOCK_NEW,GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image((GtkImageMenuItem *)menuitem,image);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(newEditor),NULL);
menuitem=gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
//save
#ifdef _USEGTK3_
saveMenu=gtk_menu_item_new_with_mnemonic("_Save");
#else
saveMenu=gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),saveMenu);
g_signal_connect(G_OBJECT(saveMenu),"activate",G_CALLBACK(saveManpage),NULL);
gtk_widget_add_accelerator((GtkWidget *)saveMenu,"activate",accgroup,'S',GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
//save as
#ifdef _USEGTK3_
saveAsMenu=gtk_menu_item_new_with_label("Save As");
#else
saveAsMenu=gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE_AS,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),saveAsMenu);
g_signal_connect(G_OBJECT(saveAsMenu),"activate",G_CALLBACK(saveAs),NULL);
gtk_widget_set_sensitive((GtkWidget*)saveAsMenu,false);
//export
#ifdef _USEGTK3_
exportMenu=gtk_menu_item_new_with_label("Export Man Page");
#else
image=gtk_image_new_from_stock(GTK_STOCK_CONVERT,GTK_ICON_SIZE_MENU);
exportMenu=gtk_image_menu_item_new_with_label("Export Man Page");
gtk_image_menu_item_set_image((GtkImageMenuItem *)exportMenu,image);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),exportMenu);
g_signal_connect(G_OBJECT(exportMenu),"activate",G_CALLBACK(exportFile),NULL);
//export as
#ifdef _USEGTK3_
exportAsMenu=gtk_menu_item_new_with_label("Export As");
#else
image=gtk_image_new_from_stock(GTK_STOCK_CONVERT,GTK_ICON_SIZE_MENU);
exportAsMenu=gtk_image_menu_item_new_with_label("Export As");
gtk_image_menu_item_set_image((GtkImageMenuItem *)exportAsMenu,image);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),exportAsMenu);
g_signal_connect(G_OBJECT(exportAsMenu),"activate",G_CALLBACK(exportFile),(void*)1);
//import
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_label("Import Manpage");
#else
image=gtk_image_new_from_stock(GTK_STOCK_OPEN,GTK_ICON_SIZE_MENU);
menuitem=gtk_image_menu_item_new_with_label("Import Manpage");
gtk_image_menu_item_set_image((GtkImageMenuItem *)menuitem,image);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(importManpage),NULL);
//import sysmanpage
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_label("Import System Manpage");
#else
image=gtk_image_new_from_stock(GTK_STOCK_OPEN,GTK_ICON_SIZE_MENU);
menuitem=gtk_image_menu_item_new_with_label("Import System Manpage");
gtk_image_menu_item_set_image((GtkImageMenuItem *)menuitem,image);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(importManpage),(void*)1);
//preview
#ifdef _USEGTK3_
previewMenu=gtk_menu_item_new_with_label("Preview Page");
#else
image=gtk_image_new_from_stock(GTK_STOCK_FIND,GTK_ICON_SIZE_MENU);
previewMenu=gtk_image_menu_item_new_with_label("Preview Page");
gtk_image_menu_item_set_image((GtkImageMenuItem *)previewMenu,image);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),previewMenu);
g_signal_connect(G_OBJECT(previewMenu),"activate",G_CALLBACK(previewPage),NULL);
//properties
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_label("Properties");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_PROPERTIES,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(redoProps),NULL);
menuitem=gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
//printmanpage
#ifdef _USEGTK3_
menuprint=gtk_menu_item_new_with_label("Print Manpage to LP");
#else
image=gtk_image_new_from_stock(GTK_STOCK_PRINT,GTK_ICON_SIZE_MENU);
menuprint=gtk_image_menu_item_new_with_label("Print Manpage to LP");
gtk_image_menu_item_set_image((GtkImageMenuItem *)menuprint,image);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuprint);
g_signal_connect(G_OBJECT(menuprint),"activate",G_CALLBACK(printFile),(void*)1);
//print manpage to pdf
#ifdef _USEGTK3_
menuprint=gtk_menu_item_new_with_label("Print Manpage To PDF");
#else
image=gtk_image_new_from_stock(GTK_STOCK_PRINT,GTK_ICON_SIZE_MENU);
menuprint=gtk_image_menu_item_new_with_label("Print Manpage To PDF");
gtk_image_menu_item_set_image((GtkImageMenuItem *)menuprint,image);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuprint);
g_signal_connect(G_OBJECT(menuprint),"activate",G_CALLBACK(printFile),(void*)2);
menuitem=gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
//close
#ifdef _USEGTK3_
menuclose=gtk_menu_item_new_with_mnemonic("_Close");
#else
menuclose=gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuclose);
g_signal_connect(G_OBJECT(menuclose),"activate",G_CALLBACK(closePage),NULL);
gtk_widget_add_accelerator((GtkWidget *)menuclose,"activate",accgroup,'W',GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
//close section
#ifdef _USEGTK3_
closeSectionMenu=gtk_menu_item_new_with_label("Delete Section");
#else
image=gtk_image_new_from_stock(GTK_STOCK_DELETE,GTK_ICON_SIZE_MENU);
closeSectionMenu=gtk_image_menu_item_new_with_label("Delete Section");
gtk_image_menu_item_set_image((GtkImageMenuItem *)closeSectionMenu,image);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),closeSectionMenu);
g_signal_connect(G_OBJECT(closeSectionMenu),"activate",G_CALLBACK(deleteSection),NULL);
menuitem=gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
//quit
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_Quit");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(doShutdown),NULL);
gtk_widget_add_accelerator((GtkWidget *)menuitem,"activate",accgroup,'Q',GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
//edit menu
menuedit=gtk_menu_item_new_with_label("Edit");
menu=gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuedit),menu);
//undo
#ifdef _USEGTK3_
undoMenu=gtk_menu_item_new_with_mnemonic("_Undo");
#else
undoMenu=gtk_image_menu_item_new_from_stock(GTK_STOCK_UNDO,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),undoMenu);
g_signal_connect(G_OBJECT(undoMenu),"activate",G_CALLBACK(undo),NULL);
gtk_widget_add_accelerator((GtkWidget *)undoMenu,"activate",accgroup,'Z',GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
//redo
#ifdef _USEGTK3_
redoMenu=gtk_menu_item_new_with_mnemonic("_Redo");
#else
redoMenu=gtk_image_menu_item_new_from_stock(GTK_STOCK_REDO,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),redoMenu);
g_signal_connect(G_OBJECT(redoMenu),"activate",G_CALLBACK(redo),NULL);
gtk_widget_add_accelerator((GtkWidget *)redoMenu,"activate",accgroup,'Z',(GdkModifierType)(GDK_SHIFT_MASK|GDK_CONTROL_MASK),GTK_ACCEL_VISIBLE);
menuitem=gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
//cut
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_Cut");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_CUT,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(cutToClip),NULL);
gtk_widget_add_accelerator((GtkWidget *)menuitem,"activate",accgroup,'X',GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
//copy
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_Copy");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_COPY,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(copyToClip),NULL);
gtk_widget_add_accelerator((GtkWidget *)menuitem,"activate",accgroup,'C',GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
//paste
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_Paste");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_PASTE,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(pasteFromClip),NULL);
gtk_widget_add_accelerator((GtkWidget *)menuitem,"activate",accgroup,'V',GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
menuitem=gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
//find
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_Find");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_FIND,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(find),NULL);
gtk_widget_add_accelerator((GtkWidget *)menuitem,"activate",accgroup,'F',GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
menuitem=gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
//prefs
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_Preferences");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(doPrefs),NULL);
//formattin menu
menuformat=gtk_menu_item_new_with_label("Formating");
menu=gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuformat),menu);
//bold
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_Bold");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_BOLD,NULL);
#endif
gtk_widget_add_accelerator((GtkWidget *)menuitem,"activate",accgroup,GDK_KEY_B,(GdkModifierType)GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(doFormat),(void*)BOLD);
//italic
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_Italic");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_ITALIC,NULL);
#endif
gtk_widget_add_accelerator((GtkWidget *)menuitem,"activate",accgroup,GDK_KEY_I,(GdkModifierType)GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(doFormat),(void*)ITALIC);
//normal
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_Clear");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_CLEAR,NULL);
#endif
gtk_widget_add_accelerator((GtkWidget *)menuitem,"activate",accgroup,GDK_KEY_R,(GdkModifierType)GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(doFormat),(void*)NORMAL);
//help
menuhelp=gtk_menu_item_new_with_label("Help");
menu=gtk_menu_new();
//about
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuhelp),menu);
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_About");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT,NULL);
#endif
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(doAbout),NULL);
//help
#ifdef _USEGTK3_
menuitem=gtk_menu_item_new_with_mnemonic("_Help");
#else
menuitem=gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP,NULL);
#endif
g_signal_connect(G_OBJECT(menuitem),"activate",G_CALLBACK(openHelp),NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu),menuitem);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),menufile);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),menuedit);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),menuformat);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar),menuhelp);
gtk_container_add(GTK_CONTAINER(window),(GtkWidget*)vbox);
gtk_widget_set_sensitive((GtkWidget*)saveButton,false);
gtk_widget_set_sensitive((GtkWidget*)saveMenu,false);
}
/*--------------------------------------------------------------------------*/
static void
add_downloading_page( GnomeDruid *wdruid, GdkPixbuf *logo )
{
GtkWidget *wpage, *wvbox, *wvbox2, *wvbox3, *wvbox4;
GtkWidget *whbox2, *whbox3, *whbox4;
GtkWidget *wlabel1, *wlabel2, *wframe;
GdkColor druid_bg_color = DRUID_BG_COLOR;
GdkColor druid_title_color = DRUID_TITLE_COLOR;
gb_debug (DEBUG_UPDATE, "START");
wpage = gnome_druid_page_standard_new_with_vals (_("Downloading..."),
logo,
NULL);
gnome_druid_page_standard_set_background(GNOME_DRUID_PAGE_STANDARD(wpage),
&druid_bg_color);
gnome_druid_page_standard_set_logo_background(GNOME_DRUID_PAGE_STANDARD(wpage),
&druid_bg_color);
gnome_druid_page_standard_set_title_foreground(GNOME_DRUID_PAGE_STANDARD(wpage),
&druid_title_color);
gnome_druid_append_page( wdruid, GNOME_DRUID_PAGE(wpage) );
wvbox = GNOME_DRUID_PAGE_STANDARD(wpage)->vbox;
wvbox2 = gtk_vbox_new( FALSE, 10 );
gtk_container_set_border_width( GTK_CONTAINER(wvbox2), 20 );
gtk_box_pack_start( GTK_BOX(wvbox), wvbox2, TRUE, FALSE, 0 );
wlabel1 = gtk_label_new( _("Please wait while GBonds downloads new redemption data.") );
gtk_box_pack_start( GTK_BOX(wvbox2), wlabel1, FALSE, TRUE, 0 );
wframe = gtk_frame_new( NULL );
gtk_box_pack_start( GTK_BOX(wvbox2), wframe, FALSE, TRUE, 0 );
whbox2 = gtk_hbox_new( FALSE, 0 );
gtk_container_set_border_width( GTK_CONTAINER(whbox2), 5 );
gtk_container_add( GTK_CONTAINER(wframe), whbox2 );
status_label = gtk_label_new( _("Status") );
gtk_label_set_justify( GTK_LABEL(status_label), GTK_JUSTIFY_LEFT );
gtk_box_pack_start( GTK_BOX(whbox2), status_label, FALSE, TRUE, 0 );
wvbox3 = gtk_vbox_new( FALSE, 2 );
gtk_box_pack_start( GTK_BOX(wvbox2), wvbox3, TRUE, FALSE, 0 );
whbox3 = gtk_hbox_new( FALSE, 0 );
gtk_box_pack_start( GTK_BOX(wvbox3), whbox3, FALSE, TRUE, 0 );
file_label = gtk_label_new( _("File") );
gtk_label_set_justify( GTK_LABEL(file_label), GTK_JUSTIFY_LEFT );
gtk_box_pack_start( GTK_BOX(whbox3), file_label, FALSE, TRUE, 0 );
file_progress = gtk_progress_bar_new();
gtk_progress_bar_set_text( GTK_PROGRESS_BAR(file_progress), "" );
gtk_box_pack_start( GTK_BOX(wvbox3), file_progress, FALSE, TRUE, 0 );
wvbox4 = gtk_vbox_new( FALSE, 2 );
gtk_box_pack_start( GTK_BOX(wvbox2), wvbox4, TRUE, FALSE, 0 );
whbox4 = gtk_hbox_new( FALSE, 0 );
gtk_box_pack_start( GTK_BOX(wvbox4), whbox4, FALSE, TRUE, 0 );
wlabel2 = gtk_label_new( _("Total") );
gtk_label_set_justify( GTK_LABEL(wlabel2), GTK_JUSTIFY_LEFT );
gtk_box_pack_start( GTK_BOX(whbox4), wlabel2, FALSE, TRUE, 0 );
total_progress = gtk_progress_bar_new();
gtk_progress_bar_set_text( GTK_PROGRESS_BAR(total_progress), "" );
gtk_box_pack_start( GTK_BOX(wvbox4), total_progress, FALSE, TRUE, 0 );
g_signal_connect_after( G_OBJECT(wpage), "prepare",
G_CALLBACK(prepare_downloading_page), NULL );
gb_debug (DEBUG_UPDATE, "END");
}
bool wxTopLevelWindowGTK::Create( wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& sizeOrig,
long style,
const wxString &name )
{
wxSize size(sizeOrig);
if (!size.IsFullySpecified())
size.SetDefaults(GetDefaultSize());
wxTopLevelWindows.Append( this );
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
return false;
}
m_title = title;
// NB: m_widget may be !=NULL if it was created by derived class' Create,
// e.g. in wxTaskBarIconAreaGTK
if (m_widget == NULL)
{
m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
{
// Tell WM that this is a dialog window and make it center
// on parent by default (this is what GtkDialog ctor does):
gtk_window_set_type_hint(GTK_WINDOW(m_widget),
GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_position(GTK_WINDOW(m_widget),
GTK_WIN_POS_CENTER_ON_PARENT);
}
else
{
if (style & wxFRAME_TOOL_WINDOW)
{
gtk_window_set_type_hint(GTK_WINDOW(m_widget),
GDK_WINDOW_TYPE_HINT_UTILITY);
// On some WMs, like KDE, a TOOL_WINDOW will still show
// on the taskbar, but on Gnome a TOOL_WINDOW will not.
// For consistency between WMs and with Windows, we
// should set the NO_TASKBAR flag which will apply
// the set_skip_taskbar_hint if it is available,
// ensuring no taskbar entry will appear.
style |= wxFRAME_NO_TASKBAR;
}
}
g_object_ref(m_widget);
}
wxWindow *topParent = wxGetTopLevelParent(m_parent);
if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
(GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
(style & wxFRAME_FLOAT_ON_PARENT)))
{
gtk_window_set_transient_for( GTK_WINDOW(m_widget),
GTK_WINDOW(topParent->m_widget) );
}
if (style & wxFRAME_NO_TASKBAR)
{
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
}
if (style & wxSTAY_ON_TOP)
{
gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
}
if (style & wxMAXIMIZE)
gtk_window_maximize(GTK_WINDOW(m_widget));
#if 0
if (!name.empty())
gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
#endif
gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
gtk_widget_set_can_focus(m_widget, false);
g_signal_connect (m_widget, "delete_event",
G_CALLBACK (gtk_frame_delete_callback), this);
// m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
m_mainWidget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show( m_mainWidget );
gtk_widget_set_can_focus(m_mainWidget, false);
gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
// m_wxwindow is the client area
m_wxwindow = wxPizza::New();
gtk_widget_show( m_wxwindow );
gtk_box_pack_start(GTK_BOX(m_mainWidget), m_wxwindow, true, true, 0);
// we donm't allow the frame to get the focus as otherwise
// the frame will grab it at arbitrary focus changes
gtk_widget_set_can_focus(m_wxwindow, false);
if (m_parent) m_parent->AddChild( this );
g_signal_connect(m_wxwindow, "size_allocate",
G_CALLBACK(size_allocate), this);
PostCreation();
#ifndef __WXGTK3__
if (pos != wxDefaultPosition)
gtk_widget_set_uposition( m_widget, m_x, m_y );
#endif
// for some reported size corrections
g_signal_connect (m_widget, "map_event",
G_CALLBACK (gtk_frame_map_callback), this);
// for iconized state
g_signal_connect (m_widget, "window_state_event",
G_CALLBACK (gtk_frame_window_state_callback), this);
// for wxMoveEvent
g_signal_connect (m_widget, "configure_event",
G_CALLBACK (gtk_frame_configure_callback), this);
// activation
g_signal_connect_after (m_widget, "focus_in_event",
G_CALLBACK (gtk_frame_focus_in_callback), this);
g_signal_connect_after (m_widget, "focus_out_event",
G_CALLBACK (gtk_frame_focus_out_callback), this);
// We need to customize the default GTK+ logic for key processing to make
// it conforming to wxWidgets event processing order.
g_signal_connect (m_widget, "key_press_event",
G_CALLBACK (wxgtk_tlw_key_press_event), NULL);
#ifdef GDK_WINDOWING_X11
#ifdef __WXGTK3__
if (GDK_IS_X11_SCREEN(gtk_window_get_screen(GTK_WINDOW(m_widget))))
#endif
{
gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK);
g_signal_connect(m_widget, "property_notify_event",
G_CALLBACK(property_notify_event), this);
}
#endif // GDK_WINDOWING_X11
// translate wx decorations styles into Motif WM hints (they are recognized
// by other WMs as well)
// always enable moving the window as we have no separate flag for enabling
// it
m_gdkFunc = GDK_FUNC_MOVE;
if ( style & wxCLOSE_BOX )
m_gdkFunc |= GDK_FUNC_CLOSE;
if ( style & wxMINIMIZE_BOX )
m_gdkFunc |= GDK_FUNC_MINIMIZE;
if ( style & wxMAXIMIZE_BOX )
m_gdkFunc |= GDK_FUNC_MAXIMIZE;
if ( (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER) )
{
m_gdkDecor = 0;
gtk_window_set_decorated(GTK_WINDOW(m_widget), false);
}
else // have border
{
m_gdkDecor = GDK_DECOR_BORDER;
if ( style & wxCAPTION )
m_gdkDecor |= GDK_DECOR_TITLE;
#if defined(GDK_WINDOWING_WAYLAND) && GTK_CHECK_VERSION(3,10,0)
else if (
GDK_IS_WAYLAND_DISPLAY(gtk_widget_get_display(m_widget)) &&
gtk_check_version(3,10,0) == NULL)
{
gtk_window_set_titlebar(GTK_WINDOW(m_widget), gtk_header_bar_new());
}
#endif
if ( style & wxSYSTEM_MENU )
m_gdkDecor |= GDK_DECOR_MENU;
if ( style & wxMINIMIZE_BOX )
m_gdkDecor |= GDK_DECOR_MINIMIZE;
if ( style & wxMAXIMIZE_BOX )
m_gdkDecor |= GDK_DECOR_MAXIMIZE;
if ( style & wxRESIZE_BORDER )
{
m_gdkFunc |= GDK_FUNC_RESIZE;
m_gdkDecor |= GDK_DECOR_RESIZEH;
}
}
m_decorSize = GetCachedDecorSize();
int w, h;
GTKDoGetSize(&w, &h);
if (style & wxRESIZE_BORDER)
{
gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h);
#ifndef __WXGTK3__
gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1);
#endif
}
else
{
gtk_window_set_resizable(GTK_WINDOW(m_widget), false);
// gtk_window_set_default_size() does not work for un-resizable windows,
// unless you set the size hints, but that causes Ubuntu's WM to make
// the window resizable even though GDK_FUNC_RESIZE is not set.
gtk_widget_set_size_request(m_widget, w, h);
}
return true;
}
void
ags_drum_output_line_init(AgsDrumOutputLine *drum_output_line)
{
g_signal_connect_after((GObject *) drum_output_line, "parent_set\0",
G_CALLBACK(ags_drum_output_line_parent_set_callback), NULL);
}
static GtkWidget *
thumbalbum_create (GimvThumbView *tv, const gchar *dest_mode)
{
ThumbViewData *tv_data;
g_return_val_if_fail (GIMV_IS_THUMB_VIEW (tv), NULL);
tv_data = g_object_get_data (G_OBJECT (tv), THUMBALBUM_LABEL);
if (!tv_data) {
tv_data = thumbalbum_new (tv);
g_return_val_if_fail (tv_data, NULL);
}
/* create zalbum widget */
tv_data->album = gimv_zalbum_new ();
if (!strcmp (THUMBALBUM2_LABEL, dest_mode)) {
gtk_widget_set_name (tv_data->album, "List2IconMode");
gimv_zlist_set_to_horizontal (GIMV_ZLIST (tv_data->album));
gimv_zalbum_set_label_position (GIMV_ZALBUM (tv_data->album),
GIMV_ZALBUM_CELL_LABEL_RIGHT);
gimv_zalbum_set_min_pixmap_size (GIMV_ZALBUM (tv_data->album),
ICON_SIZE, ICON_SIZE);
} else if (!strcmp (THUMBALBUM3_LABEL, dest_mode)) {
gtk_widget_set_name (tv_data->album, "List2ThumbMode");
album_create_title_idx_list ();
gimv_zlist_set_to_horizontal (GIMV_ZLIST (tv_data->album));
gimv_zalbum_set_label_position (GIMV_ZALBUM (tv_data->album),
GIMV_ZALBUM_CELL_LABEL_RIGHT);
gimv_zalbum_set_min_pixmap_size (GIMV_ZALBUM (tv_data->album),
tv->thumb_size,
tv->thumb_size);
} else {
gtk_widget_set_name (tv_data->album, "Thumbnail2Mode");
gimv_zalbum_set_min_pixmap_size (GIMV_ZALBUM (tv_data->album),
tv->thumb_size,
tv->thumb_size);
}
gimv_scrolled_set_auto_scroll (GIMV_SCROLLED (tv_data->album),
GIMV_SCROLLED_AUTO_SCROLL_BOTH
| GIMV_SCROLLED_AUTO_SCROLL_DND
| GIMV_SCROLLED_AUTO_SCROLL_MOTION);
gimv_scrolled_set_h_auto_scroll_resolution (GIMV_SCROLLED (tv_data->album),
20, 10);
gimv_scrolled_set_v_auto_scroll_resolution (GIMV_SCROLLED (tv_data->album),
20, 10);
gimv_zlist_set_selection_mode (GIMV_ZLIST (tv_data->album),
GTK_SELECTION_EXTENDED);
if (!strcmp (THUMBALBUM_LABEL, dest_mode)) {
gimv_zlist_set_cell_padding (GIMV_ZLIST (tv_data->album),
conf.thumbalbum_col_space,
conf.thumbalbum_row_space);
} else {
gimv_zlist_set_cell_padding (GIMV_ZLIST (tv_data->album), 5, 5);
}
gtk_widget_show (tv_data->album);
g_signal_connect_after (G_OBJECT (tv_data->album), "button_press_event",
G_CALLBACK (cb_album_button_press), tv);
g_signal_connect_after (G_OBJECT (tv_data->album), "button_release_event",
G_CALLBACK (cb_album_button_release), tv);
SIGNAL_CONNECT_TRANSRATE_SCROLL (tv_data->album);
g_signal_connect_after (G_OBJECT (tv_data->album), "key-press-event",
G_CALLBACK (cb_album_key_press), tv);
g_signal_connect_after (G_OBJECT (tv_data->album), "cell_select",
G_CALLBACK (cb_select_cell), tv);
g_signal_connect_after (G_OBJECT (tv_data->album), "cell_unselect",
G_CALLBACK (cb_unselect_cell), tv);
/* Drag and Drop */
dnd_src_set (tv_data->album, dnd_types_uri, dnd_types_uri_num);
dnd_dest_set (tv_data->album, dnd_types_uri, dnd_types_uri_num);
g_object_set_data (G_OBJECT (tv_data->album), "gimv-tab", tv);
g_signal_connect_after (G_OBJECT (tv_data->album), "drag_begin",
G_CALLBACK (gimv_thumb_view_drag_begin_cb),
tv);
g_signal_connect_after (G_OBJECT (tv_data->album), "drag_data_get",
G_CALLBACK (gimv_thumb_view_drag_data_get_cb),
tv);
g_signal_connect_after (G_OBJECT (tv_data->album), "drag_data_received",
G_CALLBACK (gimv_thumb_view_drag_data_received_cb),
tv);
g_signal_connect_after (G_OBJECT (tv_data->album), "drag-data-delete",
G_CALLBACK (gimv_thumb_view_drag_data_delete_cb),
tv);
g_signal_connect_after (G_OBJECT (tv_data->album), "drag_end",
G_CALLBACK (gimv_thumb_view_drag_end_cb), tv);
/* append thumbnail frames */
if (tv->thumblist) {
GList *node;
for (node = tv->thumblist; node; node = g_list_next (node))
thumbalbum_append_thumb_frame (tv, node->data, dest_mode);
gimv_zlist_cell_set_focus (GIMV_ZLIST (tv_data->album), 0);
}
return tv_data->album;
}
/**
* mx_list_view_set_model:
* @list_view: An #MxListView
* @model: A #ClutterModel
*
* Set the model used by the #MxListView
*/
void
mx_list_view_set_model (MxListView *list_view,
ClutterModel *model)
{
MxListViewPrivate *priv;
g_return_if_fail (MX_IS_LIST_VIEW (list_view));
g_return_if_fail (model == NULL || CLUTTER_IS_MODEL (model));
priv = list_view->priv;
if (priv->model)
{
g_signal_handlers_disconnect_by_func (priv->model,
(GCallback) model_changed_cb,
list_view);
g_signal_handlers_disconnect_by_func (priv->model,
(GCallback) row_changed_cb,
list_view);
g_signal_handlers_disconnect_by_func (priv->model,
(GCallback) row_removed_cb,
list_view);
g_object_unref (priv->model);
priv->model = NULL;
}
if (model)
{
g_return_if_fail (CLUTTER_IS_MODEL (model));
priv->model = g_object_ref (model);
priv->filter_changed = g_signal_connect (priv->model,
"filter-changed",
G_CALLBACK (model_changed_cb),
list_view);
priv->row_added = g_signal_connect (priv->model,
"row-added",
G_CALLBACK (row_changed_cb),
list_view);
priv->row_changed = g_signal_connect (priv->model,
"row-changed",
G_CALLBACK (row_changed_cb),
list_view);
/*
* model_changed_cb (called from row_changed_cb) expect the row to already
* have been removed, thus we need to use _after
*/
priv->row_removed = g_signal_connect_after (priv->model,
"row-removed",
G_CALLBACK (row_removed_cb),
list_view);
priv->sort_changed = g_signal_connect (priv->model,
"sort-changed",
G_CALLBACK (model_changed_cb),
list_view);
/*
* Only do this inside this block, setting the model to NULL should have
* the effect of preserving the view; just disconnect the handlers
*/
model_changed_cb (priv->model, list_view);
}
}
static void
nemo_window_pane_constructed (GObject *obj)
{
NemoWindowPane *pane = NEMO_WINDOW_PANE (obj);
GtkSizeGroup *header_size_group;
NemoWindow *window;
GtkActionGroup *action_group;
G_OBJECT_CLASS (nemo_window_pane_parent_class)->constructed (obj);
window = pane->window;
header_size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
gtk_size_group_set_ignore_hidden (header_size_group, FALSE);
/* build the toolbar */
action_group = nemo_window_create_toolbar_action_group (window);
pane->toolbar_action_group = action_group;
pane->tool_bar = GTK_WIDGET (nemo_toolbar_new (action_group));
g_signal_connect_object (pane->tool_bar, "notify::show-location-entry",
G_CALLBACK (location_entry_changed_cb),
pane, 0);
pane->action_group = action_group;
setup_search_action (pane);
g_signal_connect (pane->action_group, "pre-activate",
G_CALLBACK (toolbar_action_group_activated_callback), pane);
/* Pack to windows hbox (under the menu */
gtk_box_pack_start (GTK_BOX (window->details->toolbar_holder),
pane->tool_bar,
TRUE, TRUE, 0);
/* start as non-active */
nemo_window_pane_set_active (pane, FALSE);
g_settings_bind_with_mapping (nemo_window_state,
NEMO_WINDOW_STATE_START_WITH_TOOLBAR,
pane->tool_bar,
"visible",
G_SETTINGS_BIND_GET,
nemo_window_disable_chrome_mapping, NULL,
window, NULL);
/* connect to the pathbar signals */
pane->path_bar = nemo_toolbar_get_path_bar (NEMO_TOOLBAR (pane->tool_bar));
gtk_size_group_add_widget (header_size_group, pane->path_bar);
g_signal_connect_object (pane->path_bar, "path-clicked",
G_CALLBACK (path_bar_location_changed_callback), pane, 0);
g_signal_connect_object (pane->path_bar, "path-set",
G_CALLBACK (path_bar_path_set_callback), pane, 0);
/* connect to the location bar signals */
pane->location_bar = nemo_toolbar_get_location_bar (NEMO_TOOLBAR (pane->tool_bar));
gtk_size_group_add_widget (header_size_group, pane->location_bar);
nemo_clipboard_set_up_editable
(GTK_EDITABLE (nemo_location_bar_get_entry (NEMO_LOCATION_BAR (pane->location_bar))),
nemo_window_get_ui_manager (NEMO_WINDOW (window)),
TRUE);
g_signal_connect_object (pane->location_bar, "location-changed",
G_CALLBACK (navigation_bar_location_changed_callback), pane, 0);
g_signal_connect_object (pane->location_bar, "cancel",
G_CALLBACK (navigation_bar_cancel_callback), pane, 0);
g_signal_connect_object (nemo_location_bar_get_entry (NEMO_LOCATION_BAR (pane->location_bar)), "focus-in-event",
G_CALLBACK (toolbar_focus_in_callback), pane, 0);
/* connect to the search bar signals */
pane->search_bar = nemo_toolbar_get_search_bar (NEMO_TOOLBAR (pane->tool_bar));
gtk_size_group_add_widget (header_size_group, pane->search_bar);
g_signal_connect_object (pane->search_bar, "activate",
G_CALLBACK (search_bar_activate_callback), pane, 0);
g_signal_connect_object (pane->search_bar, "cancel",
G_CALLBACK (search_bar_cancel_callback), pane, 0);
g_signal_connect_object (nemo_search_bar_get_entry (NEMO_SEARCH_BAR (pane->search_bar)), "focus-in-event",
G_CALLBACK (toolbar_focus_in_callback), pane, 0);
/* initialize the notebook */
pane->notebook = g_object_new (NEMO_TYPE_NOTEBOOK, NULL);
gtk_box_pack_start (GTK_BOX (pane), pane->notebook,
TRUE, TRUE, 0);
g_signal_connect (pane->notebook,
"tab-close-request",
G_CALLBACK (notebook_tab_close_requested),
pane);
g_signal_connect_after (pane->notebook,
"button_press_event",
G_CALLBACK (notebook_button_press_cb),
pane);
g_signal_connect (pane->notebook, "popup-menu",
G_CALLBACK (notebook_popup_menu_cb),
pane);
g_signal_connect (pane->notebook,
"switch-page",
G_CALLBACK (notebook_switch_page_cb),
pane);
g_signal_connect (pane->notebook, "create-window",
G_CALLBACK (notebook_create_window_cb),
pane);
g_signal_connect (pane->notebook, "page-added",
G_CALLBACK (notebook_page_added_cb),
pane);
g_signal_connect (pane->notebook, "page-removed",
G_CALLBACK (notebook_page_removed_cb),
pane);
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (pane->notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (pane->notebook), FALSE);
gtk_notebook_set_group_name (GTK_NOTEBOOK (pane->notebook), "nemo-slots");
gtk_widget_show (pane->notebook);
gtk_container_set_border_width (GTK_CONTAINER (pane->notebook), 0);
/* Ensure that the view has some minimal size and that other parts
* of the UI (like location bar and tabs) don't request more and
* thus affect the default position of the split view paned.
*/
gtk_widget_set_size_request (GTK_WIDGET (pane), 60, 60);
/*
* If we're on the desktop we need to make sure the toolbar can never show
*/
if (NEMO_IS_DESKTOP_WINDOW(window)) {
gtk_widget_hide (GTK_WIDGET (window->details->toolbar_holder));
}
/* we can unref the size group now */
g_object_unref (header_size_group);
}
static void
mnb_zones_preview_completed_cb (ClutterAnimation *animation,
MnbZonesPreview *preview)
{
MnbZonesPreviewPrivate *priv = preview->priv;
switch (priv->anim_phase)
{
case MNB_ZP_STATIC:
/* Start zooming out */
priv->anim_phase = MNB_ZP_ZOOM_OUT;
clutter_actor_animate (CLUTTER_ACTOR (preview),
CLUTTER_EASE_IN_SINE,
220,
"zoom", 0.75,
NULL);
break;
case MNB_ZP_ZOOM_OUT:
/* Start panning */
{
guint duration = MIN (175 * fabs ((gdouble) priv->dest_workspace - priv->workspace), 525);
if (duration)
{
priv->anim_phase = MNB_ZP_PAN;
clutter_actor_animate (CLUTTER_ACTOR (preview),
CLUTTER_LINEAR,
duration,
"workspace", (gdouble)priv->dest_workspace,
NULL);
break;
}
/* If duration == 0, fall through here to the next phase*/
}
case MNB_ZP_PAN:
/* Start zooming in */
priv->anim_phase = MNB_ZP_ZOOM_IN;
clutter_actor_animate (CLUTTER_ACTOR (preview),
CLUTTER_EASE_OUT_CUBIC,
250,
/* Force workspace to destination in case
a previous pan animation is already
running. */
"workspace", (gdouble) priv->dest_workspace,
"zoom", 1.0,
NULL);
break;
case MNB_ZP_ZOOM_IN:
/* Complete the animation */
priv->anim_phase = MNB_ZP_STATIC;
g_signal_emit (preview, signals[SWITCH_COMPLETED], 0);
return;
default:
g_warning (G_STRLOC ": This shouldn't happen");
return;
}
animation = clutter_actor_get_animation (CLUTTER_ACTOR (preview));
g_signal_connect_after (animation, "completed",
G_CALLBACK (mnb_zones_preview_completed_cb), preview);
}
int main (int argc, char **argv)
{
ClutterActor *stage;
ClutterActor *text;
ClutterAnimation *animation;
ClutterColor red, green, blue;
gtk_init (&argc, &argv);
gst_init (&argc, &argv);
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
clutter_color_from_string (&red, "red");
clutter_color_from_string (&green, "green");
clutter_color_from_string (&blue, "blue");
stage = clutter_stage_new ();
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
text = g_object_new (CLUTTER_TYPE_TEXT,
"text", "Red",
"font-name", "Sans 40px",
"color", &red,
NULL);
clutter_actor_add_child (stage, text);
animation = clutter_actor_animate (text,
CLUTTER_EASE_IN_OUT_QUAD,
3000,
"x", 320.0,
"y", 240.0,
NULL);
g_signal_connect (animation, "completed",
G_CALLBACK (on_animation_completed), stage);
text = g_object_new (CLUTTER_TYPE_TEXT,
"text", "Blue",
"font-name", "Sans 40px",
"color", &blue,
"x", 640.0,
"y", 0.0,
NULL);
clutter_actor_set_anchor_point_from_gravity (text, CLUTTER_GRAVITY_NORTH_EAST);
clutter_actor_add_child (stage, text);
animation = clutter_actor_animate (text,
CLUTTER_EASE_IN_OUT_QUAD,
3000,
"x", 320.0,
"y", 240.0,
NULL);
text = g_object_new (CLUTTER_TYPE_TEXT,
"text", "Green",
"font-name", "Sans 40px",
"color", &green,
"x", 0.0,
"y", 480.0,
NULL);
clutter_actor_set_anchor_point_from_gravity (text, CLUTTER_GRAVITY_SOUTH_WEST);
clutter_actor_add_child (stage, text);
animation = clutter_actor_animate (text,
CLUTTER_EASE_IN_OUT_QUAD,
3000,
"x", 320.0,
"y", 240.0,
NULL);
g_signal_connect_after (stage, "realize",
G_CALLBACK (on_stage_realized), NULL);
clutter_actor_show (stage);
clutter_main ();
return 0;
}
static void
create_menuitem (GtkWidget *menu,
GMenuTreeEntry *entry,
GMenuTreeDirectory *alias_directory)
{
GtkWidget *menuitem;
menuitem = panel_image_menu_item_new2 ();
if (alias_directory)
panel_load_menu_image_deferred (menuitem,
panel_menu_icon_get_size (),
gmenu_tree_directory_get_icon (alias_directory),
NULL,
NULL);
else
panel_load_menu_image_deferred (menuitem,
panel_menu_icon_get_size (),
g_app_info_get_icon (G_APP_INFO (gmenu_tree_entry_get_app_info (entry))),
NULL, NULL);
setup_menuitem (menuitem,
panel_menu_icon_get_size (),
NULL,
alias_directory ? gmenu_tree_directory_get_name (alias_directory) :
g_app_info_get_display_name (G_APP_INFO (gmenu_tree_entry_get_app_info (entry))));
if (alias_directory &&
gmenu_tree_directory_get_comment (alias_directory))
panel_util_set_tooltip_text (menuitem,
gmenu_tree_directory_get_comment (alias_directory));
else if (!alias_directory) {
const char *description = g_app_info_get_description (G_APP_INFO (gmenu_tree_entry_get_app_info (entry)));
if (!description)
description = g_desktop_app_info_get_generic_name (gmenu_tree_entry_get_app_info (entry));
if (description)
panel_util_set_tooltip_text (menuitem,
description);
}
g_signal_connect_after (menuitem, "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
if (!panel_lockdown_get_panels_locked_down_s ()) {
GIcon *icon;
static GtkTargetEntry menu_item_targets[] = {
{ "text/uri-list", 0, 0 }
};
gtk_drag_source_set (menuitem,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
menu_item_targets, 1,
GDK_ACTION_COPY);
icon = g_app_info_get_icon (G_APP_INFO (gmenu_tree_entry_get_app_info (entry)));
if (icon != NULL)
gtk_drag_source_set_icon_gicon (menuitem, icon);
g_signal_connect (G_OBJECT (menuitem), "drag_begin",
G_CALLBACK (drag_begin_menu_cb), NULL);
g_signal_connect (menuitem, "drag_data_get",
G_CALLBACK (drag_data_get_menu_cb), entry);
g_signal_connect (menuitem, "drag_end",
G_CALLBACK (drag_end_menu_cb), NULL);
}
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (activate_app_def), entry);
gtk_widget_show (menuitem);
}
static
void
gsr2_create_table (GNCSplitReg2 *gsr)
{
GncTreeViewSplitReg *view;
GncTreeModelSplitReg *model;
GtkTreeModel *s_model;
GtkWidget *scrolled_window;
GtkTreeViewColumn *col;
GNCLedgerDisplay2Type ledger_type;
GtkWidget *hbox;
gdouble num_of_trans;
gchar *state_section;
GKeyFile *state_file = gnc_state_get_current();
const GncGUID * guid;
Account * account;
account = gnc_ledger_display2_leader (gsr->ledger);
guid = xaccAccountGetGUID (account);
ENTER("create table gsr=%p", gsr);
gnc_ledger_display2_set_user_data (gsr->ledger, (gpointer)gsr);
gnc_ledger_display2_set_handlers (gsr->ledger,
gnc_split_reg2_ld_destroy,
gnc_split_reg2_get_parent);
model = gnc_ledger_display2_get_split_model_register (gsr->ledger);
view = gnc_tree_view_split_reg_new_with_model (model);
g_object_unref (G_OBJECT (model));
/* State_section is used to store per register state: column widths, sort order,... */
ledger_type = gnc_ledger_display2_type (gsr->ledger);
if (ledger_type == LD2_GL && model->type == GENERAL_JOURNAL2)
state_section = g_strdup (STATE_SECTION_GEN_JOURNAL);
else if (ledger_type == LD2_SUBACCOUNT)
{
gchar guidstr[GUID_ENCODING_LENGTH+1];
guid_to_string_buff (guid, guidstr);
state_section = g_strconcat (STATE_SECTION_REG_PREFIX, " ", guidstr, " w/subaccounts", NULL);
}
else
{
gchar guidstr[GUID_ENCODING_LENGTH+1];
guid_to_string_buff (guid, guidstr);
state_section = g_strconcat (STATE_SECTION_REG_PREFIX, " ", guidstr, NULL);
}
g_object_set (G_OBJECT (view), "state-section", state_section,
"show-column-menu", FALSE, NULL);
// Create a hbox for treeview and scrollbar.
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_widget_show (hbox);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolled_window);
gtk_box_pack_start (GTK_BOX (gsr), hbox, TRUE, TRUE, 0);
num_of_trans = model->number_of_trans_in_full_tlist - 1;
gsr->scroll_adj = GTK_ADJUSTMENT (gtk_adjustment_new (model->position_of_trans_in_full_tlist, 0.0, num_of_trans + 10, 1.0, 10.0, 10.0));
gsr->scroll_bar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (gsr->scroll_adj));
gtk_widget_show (gsr->scroll_bar);
gtk_box_pack_start (GTK_BOX (hbox), gsr->scroll_bar, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (hbox), scrolled_window, TRUE, TRUE, 0);
gnc_ledger_display2_set_split_view_register (gsr->ledger, view);
/* Synchronize model state with view state
* (needed to properly set up the internal query) */
/* Restore the sort depth from saved state */
model->sort_depth = g_key_file_get_integer (state_file, state_section, "sort_depth", NULL);
g_free(state_section);
s_model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
if (s_model)
{
gint sort_col;
GtkSortType type;
if (gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (s_model), &sort_col, &type))
{
model->sort_col = sort_col;
model->sort_direction = type;
}
}
gnc_tree_view_configure_columns (GNC_TREE_VIEW (view));
if (ledger_type == LD2_GL && model->type == GENERAL_JOURNAL2)
gnc_tree_view_set_show_column_menu (GNC_TREE_VIEW (view), TRUE);
else
gnc_tree_view_set_show_column_menu (GNC_TREE_VIEW (view), FALSE);
/* This column gets all the free space */
gnc_tree_view_expand_columns (GNC_TREE_VIEW (view), "descnotes", NULL);
/* This sets the status color column, 4 is the minimum */
col = gnc_tree_view_find_column_by_name (GNC_TREE_VIEW (view), "status");
if (col != NULL)
g_object_set (G_OBJECT(col),
"resizable", FALSE,
"sizing", GTK_TREE_VIEW_COLUMN_FIXED,
"fixed-width", 4,
NULL);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), TRUE);
gtk_widget_show (GTK_WIDGET (view));
gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (view));
gtk_widget_show (GTK_WIDGET (gsr));
/* Should this be read only */
gnc_tree_view_split_reg_set_read_only (view, gsr->read_only);
/* This tells the ledger that we have a valid tree view */
gnc_ledger_display2_set_split_view_refresh (gsr->ledger, TRUE);
/* This triggers the update of the summary bar */
g_signal_connect_after (model, "refresh_status_bar",
G_CALLBACK (gsr2_redraw_all_cb), gsr); //this works
// This will keep scrollbar in sync.
g_signal_connect (model, "scroll_sync",
G_CALLBACK (gsr2_scroll_sync_cb), gsr);
/* This triggers the update of the help text */
g_signal_connect (view, "help_signal",
G_CALLBACK (gsr2_emit_help_changed), gsr); // this works
gsr2_scroll_value_changed_cb (GTK_ADJUSTMENT (gsr->scroll_adj), gsr);
/* This triggers the tooltip to change when scrolling */
g_signal_connect (gsr->scroll_adj, "value-changed",
G_CALLBACK (gsr2_scroll_value_changed_cb), gsr); // this works
/* This triggers the model update when mouse button released */
g_signal_connect (gsr->scroll_bar, "button-release-event",
G_CALLBACK (gsr2_scroll_button_event_cb), gsr);
// Connect a call back to update the sort settings.
g_signal_connect (GTK_TREE_SORTABLE (s_model), "sort-column-changed",
G_CALLBACK (gnc_split_reg2_sort_changed_cb), gsr);
LEAVE(" ");
}
static void
glade_signal_connect_func (const gchar *cb_name, GObject *obj,
const gchar *signal_name, const gchar *signal_data,
GObject *conn_obj, gboolean conn_after,
gpointer user_data)
{
/** Module with all the symbols of the program */
static GModule *mod_self = NULL;
gpointer handler_func;
/* initialize gmodule */
if (mod_self == NULL)
{
mod_self = g_module_open (NULL, 0);
g_assert (mod_self != NULL);
}
if (g_module_symbol (mod_self, cb_name, &handler_func))
{
/* found callback */
if (conn_obj)
{
if (conn_after)
{
g_signal_connect_object
(obj, signal_name,
handler_func, conn_obj,
G_CONNECT_AFTER);
}
else
{
g_signal_connect_object
(obj, signal_name,
handler_func, conn_obj,
G_CONNECT_SWAPPED);
}
}
else
{
/* no conn_obj; use standard connect */
gpointer data = NULL;
data = user_data;
if (conn_after)
{
g_signal_connect_after
(obj, signal_name,
handler_func, data);
}
else
{
g_signal_connect
(obj, signal_name,
handler_func, data);
}
}
}
else
{
g_warning("callback function not found: %s", cb_name);
}
}
MergeDialog::MergeDialog(const ustring & text)
{
event_textbuffer = 0;
extern Settings *settings;
mergedialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(mergedialog), _("Merge"));
gtk_window_set_position(GTK_WINDOW(mergedialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_modal(GTK_WINDOW(mergedialog), TRUE);
gtk_window_set_default_size(GTK_WINDOW(mergedialog), (int)(settings->genconfig.screen_width_get() * 0.8), (int)(settings->genconfig.screen_height_get() * 0.9));
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (mergedialog));
gtk_widget_show(dialog_vbox1);
label = gtk_label_new(_("The merge operation needs manual intervention. Each place that needs intervention shows two buttons with the two alternatives. Please press the buttons with the correct text."));
gtk_label_set_line_wrap(GTK_LABEL(label), true);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), label, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_SHADOW_IN);
textview = gtk_text_view_new();
gtk_widget_show(textview);
gtk_container_add(GTK_CONTAINER(scrolledwindow), textview);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(mergedialog));
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
new InDialogHelp(mergedialog, NULL, NULL, NULL);
cancelbutton = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton);
gtk_dialog_add_action_widget(GTK_DIALOG(mergedialog), cancelbutton, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default (GTK_WIDGET (cancelbutton), true);
okbutton = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton);
gtk_dialog_add_action_widget(GTK_DIALOG(mergedialog), okbutton, GTK_RESPONSE_OK);
gtk_widget_set_can_default (GTK_WIDGET (okbutton), true);
gtk_widget_set_sensitive(okbutton, false);
g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this));
g_signal_connect_after((gpointer) textbuffer, "changed", G_CALLBACK(on_textbuffer_changed), gpointer(this));
gtk_widget_grab_focus(textview);
gtk_widget_grab_default(okbutton);
load_text(text);
}
static int gtkListMapMethod(Ihandle* ih)
{
GtkScrolledWindow* scrolled_window = NULL;
GtkListStore *store;
store = gtk_list_store_new(1, G_TYPE_STRING);
if (ih->data->is_dropdown)
{
GtkCellRenderer *renderer = NULL;
if (ih->data->has_editbox)
ih->handle = gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(store), 0);
else
ih->handle = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
if (!ih->handle)
return IUP_ERROR;
g_object_set(G_OBJECT(ih->handle), "has-frame", TRUE, NULL);
if (ih->data->has_editbox)
{
GtkWidget *entry;
#if GTK_CHECK_VERSION(2, 12, 0)
GList* list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(ih->handle));
renderer = list->data;
g_list_free(list);
#endif
entry = gtk_bin_get_child(GTK_BIN(ih->handle));
iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry);
g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);
g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih);
g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih);
g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */
g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih);
g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */
g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih);
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
}
else
{
/* had to add an event box just to get get/killfocus,enter/leave events */
GtkWidget *box = gtk_event_box_new();
gtk_container_add((GtkContainer*)box, ih->handle);
iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)box);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ih->handle), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ih->handle), renderer, "text", 0, NULL);
g_signal_connect(G_OBJECT(box), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(box), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(box), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(box), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
else
GTK_WIDGET_FLAGS(box) |= GTK_CAN_FOCUS;
}
g_signal_connect(ih->handle, "changed", G_CALLBACK(gtkListComboBoxChanged), ih);
g_signal_connect(ih->handle, "notify::popup-shown", G_CALLBACK(gtkListComboBoxPopupShownChanged), ih);
if (renderer)
{
renderer->xpad = 0;
renderer->ypad = 0;
iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer);
}
}
else
{
GtkCellRenderer *renderer;
GtkTreeSelection* selection;
GtkTreeViewColumn *column;
GtkPolicyType scrollbar_policy;
ih->handle = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
if (!ih->handle)
return IUP_ERROR;
scrolled_window = (GtkScrolledWindow*)gtk_scrolled_window_new(NULL, NULL);
if (ih->data->has_editbox)
{
GtkBox* vbox = (GtkBox*)gtk_vbox_new(FALSE, 0);
GtkWidget *entry = gtk_entry_new();
gtk_widget_show(entry);
gtk_box_pack_start(vbox, entry, FALSE, FALSE, 0);
iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry);
gtk_widget_show((GtkWidget*)vbox);
gtk_box_pack_end(vbox, (GtkWidget*)scrolled_window, TRUE, TRUE, 0);
iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)vbox);
iupAttribSetStr(ih, "_IUPGTK_SCROLLED_WINDOW", (char*)scrolled_window);
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; /* focus goes only to the edit box */
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(entry) &= ~GTK_CAN_FOCUS;
g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih);
g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih);
g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */
g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(gtkListEditKeyPressEvent), ih);
g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih);
g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */
g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih);
}
else
{
iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)scrolled_window);
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkListSimpleKeyPressEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
}
column = gtk_tree_view_column_new();
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(column), renderer, "text", 0, NULL);
iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer);
g_object_set(G_OBJECT(renderer), "xpad", 0, NULL);
g_object_set(G_OBJECT(renderer), "ypad", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(ih->handle), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(ih->handle), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ih->handle), FALSE);
gtk_container_add((GtkContainer*)scrolled_window, ih->handle);
gtk_widget_show((GtkWidget*)scrolled_window);
gtk_scrolled_window_set_shadow_type(scrolled_window, GTK_SHADOW_IN);
if (ih->data->sb)
{
if (iupStrBoolean(iupAttribGetStr(ih, "AUTOHIDE")))
scrollbar_policy = GTK_POLICY_AUTOMATIC;
else
scrollbar_policy = GTK_POLICY_ALWAYS;
}
else
scrollbar_policy = GTK_POLICY_NEVER;
gtk_scrolled_window_set_policy(scrolled_window, scrollbar_policy, scrollbar_policy);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ih->handle));
if (!ih->data->has_editbox && ih->data->is_multiple)
{
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(ih->handle), TRUE);
#endif
}
else
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(gtkListSelectionChanged), ih);
g_signal_connect(G_OBJECT(ih->handle), "row-activated", G_CALLBACK(gtkListRowActivated), ih);
g_signal_connect(G_OBJECT(ih->handle), "motion-notify-event",G_CALLBACK(iupgtkMotionNotifyEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(iupgtkButtonEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(iupgtkButtonEvent), ih);
}
/* add to the parent, all GTK controls must call this. */
iupgtkBaseAddToParent(ih);
if (scrolled_window)
gtk_widget_realize((GtkWidget*)scrolled_window);
gtk_widget_realize(ih->handle);
/* configure for DRAG&DROP */
if (IupGetCallback(ih, "DROPFILES_CB"))
iupAttribSetStr(ih, "DRAGDROP", "YES");
iupListSetInitialItems(ih);
return IUP_NOERROR;
}
GotoReferenceDialog::GotoReferenceDialog(unsigned int currentbook, unsigned int currentchapter, const ustring & currentverse)
{
// Init variables
extern Settings *settings;
ProjectConfiguration *projectconfig = settings->projectconfig(settings->genconfig.project_get());
language = projectconfig->language_get();
newreference = false;
oldbook = currentbook;
oldchapter = currentchapter;
oldverse = currentverse;
go_back = false;
go_forward = false;
Shortcuts shortcuts(0);
gtkbuilder = gtk_builder_new ();
gtk_builder_add_from_file (gtkbuilder, gw_build_filename (Directories->get_package_data(), "gtkbuilder.gotoreferencedialog.xml").c_str(), NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "dialog"));
g_signal_connect((gpointer) dialog, "key_press_event", G_CALLBACK(on_key_press_event), gpointer(this));
notebook = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "notebook"));
// Enter current reference into the free entry, and select it, so user can use that.
entry_free = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "entry_free"));
gtk_widget_grab_focus(entry_free);
ustring ref = books_id_to_name(language, currentbook) + " " + convert_to_string(currentchapter) + ":" + currentverse;
gtk_entry_set_text(GTK_ENTRY(entry_free), ref.c_str());
gtk_editable_select_region(GTK_EDITABLE(entry_free), 0, -1);
// Completion for the reference entry.
completion_setup(entry_free, cpGoto);
// Signals entry.
g_signal_connect((gpointer) entry_free, "activate", G_CALLBACK(on_entry_free_activate), gpointer(this));
// Aided entry widgets.
treeview_book = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_book"));
treeview_chapter = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_chapter"));
treeview_verse = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_verse"));
// Connect to the signals of the treeviews.
g_signal_connect_after((gpointer) treeview_book, "move_cursor", G_CALLBACK(on_treeview_book_move_cursor), gpointer(this));
g_signal_connect_after((gpointer) treeview_book, "row_activated", G_CALLBACK(on_treeview_book_row_activated), gpointer(this));
g_signal_connect_after((gpointer) treeview_chapter, "move_cursor", G_CALLBACK(on_treeview_chapter_move_cursor), gpointer(this));
g_signal_connect_after((gpointer) treeview_chapter, "row_activated", G_CALLBACK(on_treeview_chapter_row_activated), gpointer(this));
g_signal_connect_after((gpointer) treeview_verse, "move_cursor", G_CALLBACK(on_treeview_verse_move_cursor), gpointer(this));
g_signal_connect_after((gpointer) treeview_verse, "row_activated", G_CALLBACK(on_treeview_verse_row_activated), gpointer(this));
// Create stores and fill the book store.
store_book = gtk_list_store_new(1, G_TYPE_STRING);
store_chapter = gtk_list_store_new(1, G_TYPE_STRING);
store_verse = gtk_list_store_new(1, G_TYPE_STRING);
vector < unsigned int >ibooks = project_get_books(settings->genconfig.project_get());
vector < ustring > ubooks;
for (unsigned int i = 0; i < ibooks.size(); i++)
ubooks.push_back(books_id_to_name(language, ibooks[i]));
listview_set_strings(treeview_book, store_book, ubooks);
// Set the stores as models for the treeviews.
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_book), GTK_TREE_MODEL(store_book));
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_chapter), GTK_TREE_MODEL(store_chapter));
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_verse), GTK_TREE_MODEL(store_verse));
// Unreference the stores once, so they get destroyed with the treeview.
g_object_unref(store_book);
g_object_unref(store_chapter);
g_object_unref(store_verse);
// Text cell renderer.
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new();
// Columns.
GtkTreeViewColumn *column_book;
column_book = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_book), column_book);
GtkTreeViewColumn *column_chapter;
column_chapter = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_chapter), column_chapter);
GtkTreeViewColumn *column_verse;
column_verse = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_verse), column_verse);
// Set up the selection for each of the tree views.
GtkTreeSelection *select_book;
select_book = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_book));
gtk_tree_selection_set_mode(select_book, GTK_SELECTION_SINGLE);
GtkTreeSelection *select_chapter;
select_chapter = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_chapter));
gtk_tree_selection_set_mode(select_chapter, GTK_SELECTION_SINGLE);
GtkTreeSelection *select_verse;
select_verse = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_verse));
gtk_tree_selection_set_mode(select_verse, GTK_SELECTION_SINGLE);
// History back.
radiobutton_back = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_back"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton_back), true);
// History forward.
radiobutton_forward = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_forward"));
// Link history button.
GSList *history_button_group = NULL;
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_back), history_button_group);
history_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_back));
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_forward), history_button_group);
history_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_forward));
// Dialog action area.
InDialogHelp * indialoghelp = new InDialogHelp(dialog, gtkbuilder, &shortcuts, NULL);
cancelbutton = indialoghelp->cancelbutton;
okbutton = indialoghelp->okbutton;
gtk_widget_grab_default(okbutton);
g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this));
}
GtkWidget* file_chooser(gpointer data,gchar* title,GabEditTypeFile type,GabEditTypeWin typewin, GtkFileChooserAction action)
{
GtkWidget *gabeditFileChooser;
gchar* patternsfiles[] = { "*",
"*.inp","*.com","*.mop","*.nw","*.psi",
"*.log","*.out","*.fchk", "*.aux","*.gab","*.xyz","*.mol2","*.mol","*.tnk","*.pdb","*.hin","*.zmt","*.gzmt",
"*.hf","*.gcube","*.cube","*.CUBE","*.grid","*.M2Msi","*.t41","*.dx","*.trj","*.irc","*.txt","*",
NULL};
GCallback *func = (GCallback *)data;
gchar* temp = NULL;
if(title)
gabeditFileChooser = gabedit_file_chooser_new(title, action);
else
{
if(action == GTK_FILE_CHOOSER_ACTION_OPEN) gabeditFileChooser = gabedit_file_chooser_new(_("Open file"), action);
else gabeditFileChooser = gabedit_file_chooser_new(_("Save file"), action);
}
if(type== GABEDIT_TYPEFILE_CUBEMOLPRO)
{
temp=patternsfiles[6];
patternsfiles[6]=patternsfiles[7];
patternsfiles[7]=temp;
temp = NULL;
};
gabedit_file_chooser_hide_hidden(GABEDIT_FILE_CHOOSER(gabeditFileChooser));
gabedit_file_chooser_set_filters(GABEDIT_FILE_CHOOSER(gabeditFileChooser), patternsfiles);
switch(type)
{
case GABEDIT_TYPEFILE_DALTON :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.out");
temp = g_strdup_printf("%s.out",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_GAMESS :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.log");
temp = g_strdup_printf("%s.log",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_FIREFLY :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.log");
temp = g_strdup_printf("%s.log",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_GAUSSIAN :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.log");
temp = g_strdup_printf("%s.log",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOLCAS :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.out");
temp = g_strdup_printf("%s.out",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOLPRO :
if(strstr(title,"geometry"))
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.out");
else
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.out");
temp = g_strdup_printf("%s.out",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOLPRO_LOG :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.log");
temp = g_strdup_printf("%s.log",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_ORCA :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.out");
temp = g_strdup_printf("%s.out",fileopen.projectname);
case GABEDIT_TYPEFILE_QCHEM :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.out");
temp = g_strdup_printf("%s.out",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_NWCHEM :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.out");
temp = g_strdup_printf("%s.out",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_PSICODE :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.out");
temp = g_strdup_printf("%s.out",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOPAC :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.out");
temp = g_strdup_printf("%s.out",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOPAC_AUX :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.aux");
temp = g_strdup_printf("%s.aux",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_ADF :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.out");
temp = g_strdup_printf("%s.out",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOLDEN :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.molden");
temp = g_strdup_printf("%s.molden",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_GABEDIT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.gab");
temp = g_strdup_printf("%s.gab",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOBCAL :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.mfj");
temp = g_strdup_printf("%s.mfj",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MPQC :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.out");
temp = g_strdup_printf("%s.out",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_XYZ :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.xyz");
temp = g_strdup_printf("%s.xyz",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOL2 :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.mol2");
temp = g_strdup_printf("%s.mol2",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOL :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.mol");
temp = g_strdup_printf("%s.mol",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_TINKER :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.tnk");
temp = g_strdup_printf("%s.tnk",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_PDB :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.pdb");
temp = g_strdup_printf("%s.pdb",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_HIN :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.hin");
temp = g_strdup_printf("%s.hin",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_AIMALL :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.sum");
temp = g_strdup_printf("%s.sum",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_GZMAT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.gzmt");
temp = g_strdup_printf("%s.gzmt",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MZMAT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.zmt");
temp = g_strdup_printf("%s.zmt",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_GAMESSINPUT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.inp");
temp = g_strdup_printf("%s.inp",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_FIREFLYINPUT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.inp");
temp = g_strdup_printf("%s.inp",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_GAUSSIANINPUT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.com");
temp = g_strdup_printf("%s.com",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_GAUSSIAN_FCHK :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.fchk");
temp = g_strdup_printf("%s.fchk",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOLCASINPUT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.com");
temp = g_strdup_printf("%s.com",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOLPROINPUT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.com");
temp = g_strdup_printf("%s.com",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_ORCAINPUT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.inp");
temp = g_strdup_printf("%s.inp",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_QCHEMINPUT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.inp");
temp = g_strdup_printf("%s.inp",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_NWCHEMINPUT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.nw");
temp = g_strdup_printf("%s.nw",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_PSICODEINPUT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.psi");
temp = g_strdup_printf("%s.psi",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOPACINPUT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.mop");
temp = g_strdup_printf("%s.mop",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_JPEG :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.jpg");
temp = g_strdup_printf("%s.jpg",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_PPM :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.ppm");
temp = g_strdup_printf("%s.ppm",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_BMP :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.bmp");
temp = g_strdup_printf("%s.bmp",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_PNG :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.png");
temp = g_strdup_printf("%s.png",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_TIF :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.tif");
temp = g_strdup_printf("%s.tif",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_PS :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.ps");
temp = g_strdup_printf("%s.ps",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_CUBEGAUSS :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.cube");
temp = g_strdup_printf("%s.cube",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_CUBEMOLPRO :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.CUBE");
temp = g_strdup_printf("%s.CUBE",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_CUBEADF :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.t41");
temp = g_strdup_printf("%s.t41",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_MOLCASGRID :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.grid");
temp = g_strdup_printf("%s.grid",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_CUBEMOLCAS :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.cube");
temp = g_strdup_printf("%s.cube",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_CUBEQCHEM :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.hf");
temp = g_strdup_printf("%s.hf",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_CUBEGABEDIT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.gcube");
temp = g_strdup_printf("%s.gcube",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_CUBEDX :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.dx");
temp = g_strdup_printf("%s.dx",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_TRJ :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.trj");
temp = g_strdup_printf("%s.trj",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_GAMESSIRC :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.irc");
temp = g_strdup_printf("%s.irc",fileopen.projectname);
break;
case GABEDIT_TYPEFILE_TXT :
gabedit_file_chooser_set_filter(GABEDIT_FILE_CHOOSER(gabeditFileChooser),"*.txt");
temp = g_strdup_printf("%s.txt",fileopen.projectname);
break;
default :break;
}
if(temp != NULL)
{
if(lastdirectory)
{
gchar* t = g_strdup_printf("%s%s%s",lastdirectory,G_DIR_SEPARATOR_S,temp);
gabedit_file_chooser_set_current_file(GABEDIT_FILE_CHOOSER(gabeditFileChooser),t);
g_free(t);
g_free(temp);
}
else
{
if(fileopen.localdir)
{
gchar* t = g_strdup_printf("%s%s%s",fileopen.localdir,G_DIR_SEPARATOR_S,temp);
gabedit_file_chooser_set_current_file(GABEDIT_FILE_CHOOSER(gabeditFileChooser),t);
g_free(t);
g_free(temp);
}
else
{
gabedit_file_chooser_set_current_file(GABEDIT_FILE_CHOOSER(gabeditFileChooser),temp);
g_free(temp);
}
}
}
else
{
if(lastdirectory)
{
gchar* t = g_strdup_printf("%s%sdump.txt",lastdirectory,G_DIR_SEPARATOR_S);
gabedit_file_chooser_set_current_file(GABEDIT_FILE_CHOOSER(gabeditFileChooser),t);
g_free(t);
}
else
if(fileopen.localdir)
{
gchar* t = g_strdup_printf("%s%sdump.txt",fileopen.localdir,G_DIR_SEPARATOR_S);
gabedit_file_chooser_set_current_file(GABEDIT_FILE_CHOOSER(gabeditFileChooser),t);
g_free(t);
}
}
if(typewin==GABEDIT_TYPEWIN_ORB)
{
if(action == GTK_FILE_CHOOSER_ACTION_OPEN) add_glarea_child(gabeditFileChooser,_("Open file "));
else add_glarea_child(gabeditFileChooser,_("Save file "));
}
else
{
add_button_windows(_(" Open file "),gabeditFileChooser);
g_signal_connect(G_OBJECT(gabeditFileChooser), "delete_event",(GCallback)destroy_button_windows,NULL);
}
g_signal_connect (gabeditFileChooser, "response", G_CALLBACK (func),GTK_OBJECT(gabeditFileChooser));
if(typewin==GABEDIT_TYPEWIN_ORB)
g_signal_connect (gabeditFileChooser, "response", G_CALLBACK (delete_child), GTK_OBJECT(gabeditFileChooser));
else
g_signal_connect (gabeditFileChooser, "response", G_CALLBACK (destroy_button_windows),GTK_OBJECT(gabeditFileChooser));
g_signal_connect_after (gabeditFileChooser, "response", G_CALLBACK (gtk_widget_destroy),GTK_OBJECT(gabeditFileChooser));
gtk_widget_show(gabeditFileChooser);
return gabeditFileChooser;
}
static void
enable_bookmarks (PlumaView *view,
PlumaPlugin *plugin)
{
GdkPixbuf *pixbuf;
pixbuf = get_bookmark_pixbuf (plugin);
/* Make sure the category pixbuf is set */
if (pixbuf)
{
GtkSourceMarkAttributes *attrs;
GtkTextBuffer *buffer;
InsertData *data;
attrs = gtk_source_mark_attributes_new ();
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
update_background_color (attrs, GTK_SOURCE_BUFFER(buffer));
gtk_source_mark_attributes_set_pixbuf (attrs, pixbuf);
g_object_unref (pixbuf);
gtk_source_view_set_mark_attributes (GTK_SOURCE_VIEW (view),
BOOKMARK_CATEGORY,
attrs,
BOOKMARK_PRIORITY);
gtk_source_view_set_show_line_marks (GTK_SOURCE_VIEW (view), TRUE);
g_signal_connect (buffer,
"notify::style-scheme",
G_CALLBACK (on_style_scheme_notify),
view);
g_signal_connect_after (buffer,
"delete-range",
G_CALLBACK (on_delete_range),
NULL);
data = g_slice_new0 (InsertData);
g_object_set_data_full (G_OBJECT (buffer),
INSERT_DATA_KEY,
data,
(GDestroyNotify) free_insert_data);
g_signal_connect (buffer,
"insert-text",
G_CALLBACK (on_insert_text_before),
data);
g_signal_connect (buffer,
"begin-user-action",
G_CALLBACK (on_begin_user_action),
data);
g_signal_connect (buffer,
"end-user-action",
G_CALLBACK (on_end_user_action),
data);
}
else
{
g_warning ("Could not set bookmark icon!");
}
}
int main (int argc, char *argv[])
{
GtkWidget *label;
GdkPixbuf *icon_pixbuf;
GError *err = NULL;
bindtextdomain(PACKAGE, LOCALEDIR);
bind_textdomain_codeset(PACKAGE, "UTF-8");
textdomain(PACKAGE);
srand (time(NULL));
gnome_program_init (APPID, APPVERSION, LIBGNOMEUI_MODULE,
argc, argv, GNOME_PARAM_POPT_TABLE, options,
GNOME_PARAM_NONE);
textbox_setup (); /* needs to be done before text boxes are created */
/* Initialize the GConf library */
if (!gconf_init (argc, argv, &err))
{
fprintf (stderr, _("Failed to init GConf: %s\n"), err->message);
g_error_free (err);
err = NULL;
}
/* Start a GConf client */
gconf_client = gconf_client_get_default ();
/* Add the GTetrinet directories to the list of directories that GConf client must watch */
gconf_client_add_dir (gconf_client, "/apps/gtetrinet/sound",
GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
gconf_client_add_dir (gconf_client, "/apps/gtetrinet/themes",
GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
gconf_client_add_dir (gconf_client, "/apps/gtetrinet/keys",
GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
gconf_client_add_dir (gconf_client, "/apps/gtetrinet/partyline",
GCONF_CLIENT_PRELOAD_ONELEVEL, NULL);
/* Request notification of change for these gconf keys */
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/sound/midi_player",
(GConfClientNotifyFunc) sound_midi_player_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/sound/enable_sound",
(GConfClientNotifyFunc) sound_enable_sound_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/sound/enable_midi",
(GConfClientNotifyFunc) sound_enable_midi_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/themes/theme_dir",
(GConfClientNotifyFunc) themes_theme_dir_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/down",
(GConfClientNotifyFunc) keys_down_changed, NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/left",
(GConfClientNotifyFunc) keys_left_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/right",
(GConfClientNotifyFunc) keys_right_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/rotate_left",
(GConfClientNotifyFunc) keys_rotate_left_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/rotate_right",
(GConfClientNotifyFunc) keys_rotate_right_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/drop",
(GConfClientNotifyFunc) keys_drop_changed, NULL,
NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/message",
(GConfClientNotifyFunc) keys_message_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/discard",
(GConfClientNotifyFunc) keys_discard_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special1",
(GConfClientNotifyFunc) keys_special1_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special2",
(GConfClientNotifyFunc) keys_special2_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special3",
(GConfClientNotifyFunc) keys_special3_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special4",
(GConfClientNotifyFunc) keys_special4_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special5",
(GConfClientNotifyFunc) keys_special5_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special6",
(GConfClientNotifyFunc) keys_special6_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/keys/special_self",
(GConfClientNotifyFunc) keys_special_self_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/partyline/enable_timestamps",
(GConfClientNotifyFunc) partyline_enable_timestamps_changed,
NULL, NULL, NULL);
gconf_client_notify_add (gconf_client, "/apps/gtetrinet/partyline/enable_channel_list",
(GConfClientNotifyFunc) partyline_enable_channel_list_changed,
NULL, NULL, NULL);
/* load settings */
config_loadconfig ();
/* initialise some stuff */
fields_init ();
if (!g_thread_supported()) g_thread_init (NULL);
/* first set up the display */
/* create the main window */
app = gnome_app_new (APPID, APPNAME);
g_signal_connect (G_OBJECT(app), "destroy",
GTK_SIGNAL_FUNC(destroymain), NULL);
keypress_signal = g_signal_connect (G_OBJECT(app), "key-press-event",
GTK_SIGNAL_FUNC(keypress), NULL);
g_signal_connect (G_OBJECT(app), "key-release-event",
GTK_SIGNAL_FUNC(keyrelease), NULL);
gtk_widget_set_events (app, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
gtk_window_set_resizable (GTK_WINDOW (app), TRUE);
/* create and set the window icon */
icon_pixbuf = gdk_pixbuf_new_from_file (PIXMAPSDIR "/gtetrinet.png", NULL);
if (icon_pixbuf)
{
gtk_window_set_icon (GTK_WINDOW (app), icon_pixbuf);
gdk_pixbuf_unref (icon_pixbuf);
}
/* create the notebook */
notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK(notebook), GTK_POS_TOP);
/* put it in the main window */
gnome_app_set_contents (GNOME_APP(app), notebook);
/* make menus + toolbar */
make_menus (GNOME_APP(app));
/* create the pages in the notebook */
fieldswidget = fields_page_new ();
gtk_widget_set_sensitive (fieldswidget, TRUE);
gtk_widget_show (fieldswidget);
pfields = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER(pfields), 0);
gtk_container_add (GTK_CONTAINER(pfields), fieldswidget);
gtk_widget_show (pfields);
g_object_set_data (G_OBJECT(fieldswidget), "title", "Playing Fields"); // FIXME
label = pixmapdata_label (fields_xpm, _("Playing Fields"));
gtk_widget_show (label);
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), pfields, label);
partywidget = partyline_page_new ();
gtk_widget_show (partywidget);
pparty = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER(pparty), 0);
gtk_container_add (GTK_CONTAINER(pparty), partywidget);
gtk_widget_show (pparty);
g_object_set_data (G_OBJECT(partywidget), "title", "Partyline"); // FIXME
label = pixmapdata_label (partyline_xpm, _("Partyline"));
gtk_widget_show (label);
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), pparty, label);
winlistwidget = winlist_page_new ();
gtk_widget_show (winlistwidget);
pwinlist = gtk_hbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER(pwinlist), 0);
gtk_container_add (GTK_CONTAINER(pwinlist), winlistwidget);
gtk_widget_show (pwinlist);
g_object_set_data (G_OBJECT(winlistwidget), "title", "Winlist"); // FIXME
label = pixmapdata_label (winlist_xpm, _("Winlist"));
gtk_widget_show (label);
gtk_notebook_append_page (GTK_NOTEBOOK(notebook), pwinlist, label);
/* add signal to focus the text entry when switching to the partyline page*/
g_signal_connect_after(G_OBJECT (notebook), "switch-page",
GTK_SIGNAL_FUNC (switch_focus),
NULL);
gtk_widget_show (notebook);
g_object_set (G_OBJECT (notebook), "can-focus", FALSE, NULL);
partyline_show_channel_list (list_enabled);
gtk_widget_show (app);
// gtk_widget_set_size_request (partywidget, 480, 360);
// gtk_widget_set_size_request (winlistwidget, 480, 360);
/* initialise some stuff */
commands_checkstate ();
/* check command line params */
#ifdef DEBUG
printf ("option_connect: %s\n"
"option_nick: %s\n"
"option_team: %s\n"
"option_pass: %s\n"
"option_spec: %i\n",
option_connect, option_nick, option_team,
option_pass, option_spec);
#endif
if (option_nick) GTET_O_STRCPY(nick, option_nick);
if (option_team) GTET_O_STRCPY(team, option_team);
if (option_pass) GTET_O_STRCPY(specpassword, option_pass);
if (option_spec) spectating = TRUE;
if (option_connect) {
client_init (option_connect, nick);
}
/* Don't schedule if data is ready, glib should do this itself,
* but welcome to anything that works... */
g_main_context_set_poll_func(NULL, gtetrinet_poll_func);
/* gtk_main() */
gtk_main ();
client_disconnect ();
/* cleanup */
fields_cleanup ();
sound_stopmidi ();
return 0;
}
void
gw_spellcheck_set_entry (GwSpellcheck *spellcheck, GtkEntry *entry)
{
GwSpellcheckPrivate *priv;
LwPreferences *preferences;
priv = spellcheck->priv;
preferences = gw_application_get_preferences (priv->application);
//Remove the old signals
if (priv->entry != NULL)
{
if (priv->signalid[GW_SPELLCHECK_SIGNALID_DRAW] != 0)
g_signal_handler_disconnect (G_OBJECT (priv->entry), priv->signalid[GW_SPELLCHECK_SIGNALID_DRAW]);
if (priv->signalid[GW_SPELLCHECK_SIGNALID_CHANGED] != 0)
g_signal_handler_disconnect (G_OBJECT (priv->entry), priv->signalid[GW_SPELLCHECK_SIGNALID_CHANGED]);
if (priv->signalid[GW_SPELLCHECK_SIGNALID_POPULATE_POPUP] != 0)
g_signal_handler_disconnect (G_OBJECT (priv->entry), priv->signalid[GW_SPELLCHECK_SIGNALID_POPULATE_POPUP]);
if (priv->signalid[GW_SPELLCHECK_SIGNALID_DESTROY] != 0)
g_signal_handler_disconnect (G_OBJECT (priv->entry), priv->signalid[GW_SPELLCHECK_SIGNALID_DESTROY]);
g_object_remove_weak_pointer (G_OBJECT (priv->entry), (gpointer*) (&(priv->entry)));
}
//Set the entry pointer
priv->entry = entry;
if (entry == NULL) return;
g_object_add_weak_pointer (G_OBJECT (priv->entry), (gpointer*) (&(priv->entry)));
//set the new signals
priv->signalid[GW_SPELLCHECK_SIGNALID_DICTIONARY] = lw_preferences_add_change_listener_by_schema (
preferences,
LW_SCHEMA_BASE,
LW_KEY_SPELLCHECK_DICTIONARY,
gw_spellcheck_sync_dictionary_cb,
spellcheck
);
priv->signalid[GW_SPELLCHECK_SIGNALID_RK_CONV] = lw_preferences_add_change_listener_by_schema (
preferences,
LW_SCHEMA_BASE,
LW_KEY_ROMAJI_TO_FURIGANA,
gw_spellcheck_sync_rk_conv_cb,
spellcheck
);
priv->signalid[GW_SPELLCHECK_SIGNALID_DRAW] = g_signal_connect_after (
G_OBJECT (entry),
"draw",
G_CALLBACK (gw_spellcheck_draw_underline_cb),
spellcheck
);
priv->signalid[GW_SPELLCHECK_SIGNALID_CHANGED] = g_signal_connect (
G_OBJECT (entry),
"changed",
G_CALLBACK (gw_spellcheck_queue_cb),
spellcheck
);
priv->signalid[GW_SPELLCHECK_SIGNALID_BUTTON_PRESS_EVENT] = g_signal_connect (
G_OBJECT (entry),
"button-press-event",
G_CALLBACK (gw_spellcheck_button_press_event_cb),
spellcheck
);
priv->signalid[GW_SPELLCHECK_SIGNALID_POPULATE_POPUP] = g_signal_connect (
G_OBJECT (entry),
"populate-popup",
G_CALLBACK (gw_spellcheck_populate_popup_cb),
spellcheck
);
priv->signalid[GW_SPELLCHECK_SIGNALID_DESTROY] = g_signal_connect_swapped (
G_OBJECT (entry),
"destroy",
G_CALLBACK (gw_spellcheck_remove_signals),
spellcheck
);
gw_spellcheck_queue (spellcheck);
}
void conterm_init(void)
{
GtkWidget *console;
#ifdef G_OS_UNIX
gchar *error = NULL;
int pty_master;
char *pty_name;
#endif
last_console_fd = -1;
#ifdef G_OS_UNIX
pty_slave = -1;
slave_pty_name = NULL;
program_window = get_widget("program_window");
console = vte_terminal_new();
gtk_widget_show(console);
program_terminal = VTE_TERMINAL(console);
g_object_ref(program_terminal);
gtk_container_add(GTK_CONTAINER(program_window), console);
g_signal_connect_after(program_terminal, "realize", G_CALLBACK(on_vte_realize), NULL);
terminal_parent = get_widget("terminal_parent");
g_signal_connect(terminal_parent, "delete-event", G_CALLBACK(on_terminal_parent_delete),
NULL);
terminal_window = get_widget("terminal_window");
terminal_show = GTK_CHECK_MENU_ITEM(get_widget("terminal_show"));
if (pref_terminal_padding)
{
gint vte_border_x, vte_border_y;
#if VTE_CHECK_VERSION(0, 24, 0)
GtkBorder *border = NULL;
gtk_widget_style_get(console, "inner-border", &border, NULL);
if (border)
{
vte_border_x = border->left + border->right;
vte_border_y = border->top + border->bottom;
gtk_border_free(border);
}
else
vte_border_x = vte_border_y = 2;
#else /* VTE 0.24.0 */
/* VTE manual says "deprecated since 0.26", but it's since 0.24 */
vte_terminal_get_padding(program_terminal, &vte_border_x, &vte_border_y);
#endif /* VTE 0.24.0 */
pref_terminal_width += vte_border_x;
pref_terminal_height += vte_border_y;
pref_terminal_padding = FALSE;
}
if (openpty(&pty_master, &pty_slave, NULL, NULL, NULL) == 0 &&
grantpt(pty_master) == 0 && unlockpt(pty_master) == 0 &&
(pty_name = ttyname(pty_slave)) != NULL)
{
#if VTE_CHECK_VERSION(0, 25, 0)
GError *gerror = NULL;
VtePty *pty = vte_pty_new_foreign(pty_master, &gerror);
if (pty)
{
vte_terminal_set_pty_object(program_terminal, pty);
slave_pty_name = g_strdup(pty_name);
}
else
{
error = g_strdup(gerror->message);
g_error_free(gerror);
}
#else /* VTE 0.25.0 */
vte_terminal_set_pty(program_terminal, pty_master);
slave_pty_name = g_strdup(pty_name);
#endif /* VTE 0.25.0 */
}
else
error = g_strdup_printf("pty: %s", g_strerror(errno));
if (error)
{
gtk_widget_set_sensitive(program_window, FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(terminal_show), FALSE);
msgwin_status_add(_("Scope: %s."), error);
g_free(error);
}
else
menu_connect("terminal_menu", &terminal_menu_info, GTK_WIDGET(program_terminal));
#else /* G_OS_UNIX */
gtk_widget_hide(get_widget("program_window"));
#endif /* G_OS_UNIX */
#ifdef G_OS_UNIX
if (pref_debug_console_vte)
{
console = vte_terminal_new();
gtk_widget_show(console);
debug_console = VTE_TERMINAL(console);
dc_output = console_output;
dc_output_nl = console_output_nl;
g_signal_connect_after(debug_console, "realize", G_CALLBACK(on_vte_realize), NULL);
menu_connect("console_menu", &console_menu_info, console);
}
else
#endif /* G_OS_UNIX */
{
static const char *const colors[NFD] = { "#00C0C0", "#C0C0C0", "#C00000",
"#C0C0C0", "#C000C0" };
guint i;
#ifdef G_OS_UNIX
debug_console = NULL;
#endif
dc_chars = 0;
console = get_widget("debug_context");
context_apply_config(console);
debug_context = GTK_TEXT_VIEW(console);
dc_output = context_output;
dc_output_nl = context_output_nl;
context = gtk_text_view_get_buffer(debug_context);
for (i = 0; i < NFD; i++)
{
fd_tags[i] = gtk_text_buffer_create_tag(context, NULL, "foreground",
colors[i], NULL);
}
g_signal_connect(console, "button-press-event",
G_CALLBACK(on_console_button_3_press),
menu_connect("console_menu", &console_menu_info, NULL));
}
gtk_container_add(GTK_CONTAINER(get_widget("debug_window")), console);
g_signal_connect(console, "key-press-event", G_CALLBACK(on_console_key_press), NULL);
}
static void
uim_cand_win_horizontal_gtk_init (UIMCandWinHorizontalGtk *horizontal_cwin)
{
gint col;
GtkWidget *viewport;
UIMCandWinGtk *cwin;
cwin = UIM_CAND_WIN_GTK(horizontal_cwin);
horizontal_cwin->buttons = g_ptr_array_new();
horizontal_cwin->selected = NULL;
#if GTK_CHECK_VERSION(3, 4, 0)
cwin->view = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(cwin->view), 10);
#else
cwin->view = gtk_table_new(1, DEFAULT_NR_CELLS, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(cwin->view), 10);
#endif
viewport = gtk_viewport_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(viewport), cwin->view);
gtk_container_add(GTK_CONTAINER(cwin->scrolled_window), viewport);
gtk_container_set_resize_mode(GTK_CONTAINER(viewport), GTK_RESIZE_PARENT);
for (col = 0; col < DEFAULT_NR_CELLS; col++) {
GtkWidget *button;
GtkWidget *label;
struct index_button *idxbutton;
button = gtk_event_box_new();
gtk_event_box_set_above_child(GTK_EVENT_BOX(button), TRUE);
label = gtk_label_new("");
gtk_container_add(GTK_CONTAINER(button), label);
scale_label(GTK_EVENT_BOX(button), PANGO_SCALE_LARGE);
g_signal_connect(button, "button-press-event", G_CALLBACK(button_clicked), horizontal_cwin);
#if GTK_CHECK_VERSION(2, 90, 0)
g_signal_connect_after(label, "draw", G_CALLBACK(label_draw), horizontal_cwin);
#else
g_signal_connect_after(label, "expose-event", G_CALLBACK(label_exposed), horizontal_cwin);
#endif
#if GTK_CHECK_VERSION(3, 4, 0)
gtk_widget_set_hexpand(button, TRUE);
gtk_widget_set_vexpand(button, TRUE);
gtk_grid_attach(GTK_GRID(cwin->view), button, col, 0, 1, 1);
#else
gtk_table_attach_defaults(GTK_TABLE(cwin->view), button, col, col + 1, 0, 1);
#endif
idxbutton = g_malloc(sizeof(struct index_button));
if (idxbutton) {
idxbutton->button = GTK_EVENT_BOX(button);
clear_button(idxbutton, col);
}
g_ptr_array_add(horizontal_cwin->buttons, idxbutton);
}
gtk_widget_show_all(cwin->view);
gtk_widget_show(viewport);
gtk_widget_set_size_request(cwin->num_label, DEFAULT_MIN_WINDOW_WIDTH, -1);
gtk_window_set_default_size(GTK_WINDOW(cwin), DEFAULT_MIN_WINDOW_WIDTH, -1);
gtk_window_set_resizable(GTK_WINDOW(cwin), FALSE);
}
void gldi_dialog_init_internals (CairoDialog *pDialog, CairoDialogAttr *pAttribute)
{
pDialog->container.iface.animation_loop = _animation_loop;
//\________________ set up the window
GtkWidget *pWindow = pDialog->container.pWidget;
gtk_window_set_title (GTK_WINDOW (pWindow), "cairo-dock-dialog");
if (! pAttribute->pInteractiveWidget && ! pAttribute->pActionFunc) // not an interactive dialog
gtk_window_set_type_hint (GTK_WINDOW (pDialog->container.pWidget), GDK_WINDOW_TYPE_HINT_SPLASHSCREEN); // pour ne pas prendre le focus.
gtk_widget_add_events (pWindow, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
gtk_window_resize (GTK_WINDOW (pWindow), CAIRO_DIALOG_MIN_SIZE, CAIRO_DIALOG_MIN_SIZE);
gtk_window_set_keep_above (GTK_WINDOW (pWindow), TRUE);
pDialog->pIcon = pAttribute->pIcon;
if (pAttribute->bForceAbove) // try to force it above other windows (with most WM, it will still stay below fullscreen windows).
{
gtk_window_set_keep_above (GTK_WINDOW (pDialog->container.pWidget), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (pDialog->container.pWidget), GDK_WINDOW_TYPE_HINT_DOCK); // should be called before the window becomes visible
}
//\________________ load the message
if (pAttribute->cText != NULL)
{
pDialog->cText = g_strdup (pAttribute->cText); // it may be a const string, so duplicate it
pDialog->pTextBuffer = _cairo_dock_create_dialog_text_surface (pAttribute->cText,
pAttribute->bUseMarkup,
&pDialog->iTextWidth, &pDialog->iTextHeight);
///pDialog->iTextTexture = cairo_dock_create_texture_from_surface (pDialog->pTextBuffer);
}
pDialog->bUseMarkup = pAttribute->bUseMarkup; // remember this attribute, in case another text is set (with cairo_dock_set_dialog_message).
//\________________ load the icon
if (pAttribute->cImageFilePath != NULL)
{
pDialog->pIconBuffer = _cairo_dock_create_dialog_icon_surface (pAttribute->cImageFilePath, pAttribute->pIcon, pAttribute->iIconSize, &pDialog->iIconSize);
///pDialog->iIconTexture = cairo_dock_create_texture_from_surface (pDialog->pIconBuffer);
}
//\________________ load the interactive widget
if (pAttribute->pInteractiveWidget != NULL)
{
pDialog->pInteractiveWidget = pAttribute->pInteractiveWidget;
GtkRequisition requisition;
gtk_widget_get_preferred_size (pAttribute->pInteractiveWidget, &requisition, NULL);
pDialog->iInteractiveWidth = requisition.width;
pDialog->iInteractiveHeight = requisition.height;
}
//\________________ load the buttons
pDialog->pUserData = pAttribute->pUserData;
pDialog->pFreeUserDataFunc = pAttribute->pFreeDataFunc;
if (pAttribute->cButtonsImage != NULL && pAttribute->pActionFunc != NULL)
{
int i;
for (i = 0; pAttribute->cButtonsImage[i] != NULL; i++);
pDialog->iNbButtons = i;
pDialog->action_on_answer = pAttribute->pActionFunc;
pDialog->pButtons = g_new0 (CairoDialogButton, pDialog->iNbButtons);
const gchar *cButtonImage;
for (i = 0; i < pDialog->iNbButtons; i++)
{
cButtonImage = pAttribute->cButtonsImage[i];
if (strcmp (cButtonImage, "ok") == 0)
{
pDialog->pButtons[i].iDefaultType = 1;
}
else if (strcmp (cButtonImage, "cancel") == 0)
{
pDialog->pButtons[i].iDefaultType = 0;
}
else
{
gchar *cButtonPath;
if (*cButtonImage != '/')
cButtonPath = cairo_dock_search_icon_s_path (cButtonImage,
MAX (myDialogsParam.iDialogButtonWidth, myDialogsParam.iDialogButtonHeight));
else
cButtonPath = (gchar*)cButtonImage;
pDialog->pButtons[i].pSurface = cairo_dock_create_surface_from_image_simple (cButtonPath,
myDialogsParam.iDialogButtonWidth,
myDialogsParam.iDialogButtonHeight);
if (cButtonPath != cButtonImage)
g_free (cButtonPath);
///pDialog->pButtons[i].iTexture = cairo_dock_create_texture_from_surface (pDialog->pButtons[i].pSurface);
}
}
}
else
{
pDialog->bNoInput = pAttribute->bNoInput;
}
//\________________ set a decorator.
cairo_dock_set_dialog_decorator_by_name (pDialog, (pAttribute->cDecoratorName ? pAttribute->cDecoratorName : myDialogsParam.cDecoratorName));
if (pDialog->pDecorator != NULL)
pDialog->pDecorator->set_size (pDialog);
//\________________ Maintenant qu'on connait tout, on calcule les tailles des divers elements.
_compute_dialog_sizes (pDialog);
pDialog->container.iWidth = pDialog->iBubbleWidth + pDialog->iLeftMargin + pDialog->iRightMargin;
pDialog->container.iHeight = pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iMinBottomGap;
//\________________ On reserve l'espace pour les decorations.
GtkWidget *pMainHBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add (GTK_CONTAINER (pDialog->container.pWidget), pMainHBox);
pDialog->pLeftPaddingBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
g_object_set (pDialog->pLeftPaddingBox, "width-request", pDialog->iLeftMargin, NULL);
gtk_box_pack_start (GTK_BOX (pMainHBox),
pDialog->pLeftPaddingBox,
FALSE,
FALSE,
0);
pDialog->pWidgetLayout = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (pMainHBox),
pDialog->pWidgetLayout,
FALSE,
FALSE,
0);
pDialog->pRightPaddingBox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
g_object_set (pDialog->pRightPaddingBox, "width-request", pDialog->iRightMargin, NULL);
gtk_box_pack_start (GTK_BOX (pMainHBox),
pDialog->pRightPaddingBox,
FALSE,
FALSE,
0);
//\________________ On reserve l'espace pour les elements.
if (pDialog->container.bDirectionUp)
pDialog->pTopWidget = _cairo_dock_add_dialog_internal_box (pDialog, 0, pDialog->iTopMargin, FALSE);
else
pDialog->pTipWidget = _cairo_dock_add_dialog_internal_box (pDialog, 0, pDialog->iMinBottomGap + pDialog->iBottomMargin, TRUE);
if (pDialog->iMessageWidth != 0 && pDialog->iMessageHeight != 0)
{
pDialog->pMessageWidget = _cairo_dock_add_dialog_internal_box (pDialog, pDialog->iMessageWidth, pDialog->iMessageHeight, FALSE);
}
if (pDialog->pInteractiveWidget != NULL)
{
gtk_box_pack_start (GTK_BOX (pDialog->pWidgetLayout),
pDialog->pInteractiveWidget,
FALSE,
FALSE,
0);
gtk_window_present (GTK_WINDOW (pDialog->container.pWidget));
gtk_widget_grab_focus (pDialog->pInteractiveWidget);
// set a MenuItem style to the dialog, so that the interactive widget can use the style defined for menu-items (either from the GTK theme, or from our own .css), and therefore be well integrated into the dialog, as if it was inside a menu.
GtkStyleContext *ctx = gtk_widget_get_style_context (pDialog->pWidgetLayout);
gtk_style_context_add_class (ctx, myDialogsParam.bUseDefaultColors && myStyleParam.bUseSystemColors ? GTK_STYLE_CLASS_MENUITEM : "gldimenuitem");
}
if (pDialog->pButtons != NULL)
{
pDialog->pButtonsWidget = _cairo_dock_add_dialog_internal_box (pDialog, pDialog->iButtonsWidth, pDialog->iButtonsHeight, FALSE);
}
if (pDialog->container.bDirectionUp)
pDialog->pTipWidget = _cairo_dock_add_dialog_internal_box (pDialog, 0, pDialog->iMinBottomGap + pDialog->iBottomMargin, TRUE);
else
pDialog->pTopWidget = _cairo_dock_add_dialog_internal_box (pDialog, 0, pDialog->iTopMargin, TRUE);
gtk_widget_show_all (pDialog->container.pWidget);
//\________________ load the input shape.
if (pDialog->bNoInput)
{
_cairo_dock_set_dialog_input_shape (pDialog);
}
//\________________ connect the signals to the window
g_signal_connect (G_OBJECT (pDialog->container.pWidget),
"draw",
G_CALLBACK (on_expose_dialog),
pDialog);
g_signal_connect_after (G_OBJECT (pDialog->container.pWidget),
"draw",
G_CALLBACK (on_expose_dialog_after),
pDialog);
g_signal_connect (G_OBJECT (pDialog->container.pWidget),
"configure-event",
G_CALLBACK (on_configure_dialog),
pDialog);
g_signal_connect (G_OBJECT (pDialog->container.pWidget),
"unmap-event",
G_CALLBACK (on_unmap_dialog),
pDialog); // prevent dialogs from being hidden (for instance by a 'show-desktop' event), because they might be modal
g_signal_connect (G_OBJECT (pDialog->container.pWidget),
"map-event",
G_CALLBACK (on_map_dialog),
pDialog); // some WM (like GS) prevent the focus to be taken, so we have to force it whenever the dialog is shown (creation or unhide).
if (pDialog->pInteractiveWidget != NULL && pDialog->pButtons == NULL) // the dialog has no button to be closed, so it can be closed by clicking on it. But some widget (like the GTK calendar) let pass the click to their parent (= the dialog), which then close it. To prevent this, we memorize the last click on the widget.
g_signal_connect (G_OBJECT (pDialog->pInteractiveWidget),
"button-press-event",
G_CALLBACK (on_button_press_widget),
pDialog);
cairo_dock_launch_animation (CAIRO_CONTAINER (pDialog));
}
int
main (int argc, char **argv)
{
AppearanceData *data;
GtkWidget *w;
gchar *install_filename = NULL;
gchar *start_page = NULL;
gchar **wallpaper_files = NULL;
GOptionContext *option_context;
GOptionEntry option_entries[] = {
{ "install-theme",
'i',
G_OPTION_FLAG_IN_MAIN,
G_OPTION_ARG_FILENAME,
&install_filename,
N_("Specify the filename of a theme to install"),
N_("filename") },
{ "show-page",
'p',
G_OPTION_FLAG_IN_MAIN,
G_OPTION_ARG_STRING,
&start_page,
/* TRANSLATORS: don't translate the terms in brackets */
N_("Specify the name of the page to show (theme|background|fonts|interface)"),
N_("page") },
{ G_OPTION_REMAINING,
0,
G_OPTION_FLAG_IN_MAIN,
G_OPTION_ARG_FILENAME_ARRAY,
&wallpaper_files,
NULL,
N_("[WALLPAPER...]") },
{ NULL }
};
option_context = g_option_context_new (NULL);
g_option_context_add_main_entries (option_context, option_entries, GETTEXT_PACKAGE);
/* init */
data = init_appearance_data (&argc, &argv, option_context);
if (!data)
return 1;
/* init tabs */
themes_init (data);
style_init (data);
desktop_init (data, (const gchar **) wallpaper_files);
g_strfreev (wallpaper_files);
font_init (data);
/* init support for other window managers */
support_init (data);
/* prepare the main window */
w = appearance_capplet_get_widget (data, "appearance_window");
capplet_set_icon (w, "preferences-desktop-theme");
gtk_widget_show_all (w);
g_signal_connect_after (w, "response",
(GCallback) main_window_response, data);
/* default to background page if files were given on the command line */
if (wallpaper_files && !install_filename && !start_page)
start_page = g_strdup ("background");
if (start_page != NULL) {
gchar *page_name;
page_name = g_strconcat (start_page, "_vbox", NULL);
g_free (start_page);
w = appearance_capplet_get_widget (data, page_name);
if (w != NULL) {
GtkNotebook *nb;
gint pindex;
nb = GTK_NOTEBOOK (appearance_capplet_get_widget (data, "main_notebook"));
pindex = gtk_notebook_page_num (nb, w);
if (pindex != -1)
gtk_notebook_set_current_page (nb, pindex);
}
g_free (page_name);
}
if (install_filename != NULL) {
GFile *inst = g_file_new_for_commandline_arg (install_filename);
g_free (install_filename);
mate_theme_install (inst, GTK_WINDOW (w));
g_object_unref (inst);
}
g_option_context_free (option_context);
/* start the mainloop */
gtk_main ();
gdk_threads_leave ();
/* free stuff */
g_free (data);
return 0;
}
bool wxListBox::Create( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
long style, const wxValidator& validator,
const wxString &name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxListBox creation failed") );
return false;
}
m_widget = gtk_scrolled_window_new( NULL, NULL );
g_object_ref(m_widget);
if (style & wxLB_ALWAYS_SB)
{
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS );
}
else
{
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
}
GTKScrolledWindowSetBorder(m_widget, style);
m_treeview = GTK_TREE_VIEW( gtk_tree_view_new( ) );
//wxListBox doesn't have a header :)
//NB: If enabled SetFirstItem doesn't work correctly
gtk_tree_view_set_headers_visible(m_treeview, FALSE);
#if wxUSE_CHECKLISTBOX
if(m_hasCheckBoxes)
((wxCheckListBox*)this)->DoCreateCheckList();
#endif // wxUSE_CHECKLISTBOX
// Create the data column
gtk_tree_view_insert_column_with_attributes(m_treeview, -1, "",
gtk_cell_renderer_text_new(),
"text",
WXLISTBOX_DATACOLUMN, NULL);
// Now create+set the model (GtkListStore) - first argument # of columns
#if wxUSE_CHECKLISTBOX
if(m_hasCheckBoxes)
m_liststore = gtk_list_store_new(2, G_TYPE_BOOLEAN,
GTK_TYPE_TREE_ENTRY);
else
#endif
m_liststore = gtk_list_store_new(1, GTK_TYPE_TREE_ENTRY);
gtk_tree_view_set_model(m_treeview, GTK_TREE_MODEL(m_liststore));
g_object_unref (m_liststore); //free on treeview destruction
// Disable the pop-up textctrl that enables searching - note that
// the docs specify that even if this disabled (which we are doing)
// the user can still have it through the start-interactive-search
// key binding...either way we want to provide a searchequal callback
// NB: If this is enabled a doubleclick event (activate) gets sent
// on a successful search
gtk_tree_view_set_search_column(m_treeview, WXLISTBOX_DATACOLUMN);
gtk_tree_view_set_search_equal_func(m_treeview,
(GtkTreeViewSearchEqualFunc) gtk_listbox_searchequal_callback,
this,
NULL);
gtk_tree_view_set_enable_search(m_treeview, FALSE);
GtkSelectionMode mode;
// GTK_SELECTION_EXTENDED is a deprecated synonym for GTK_SELECTION_MULTIPLE
if ( style & (wxLB_MULTIPLE | wxLB_EXTENDED) )
{
mode = GTK_SELECTION_MULTIPLE;
}
else // no multi-selection flags specified
{
m_windowStyle |= wxLB_SINGLE;
// Notice that we must use BROWSE and not GTK_SELECTION_SINGLE because
// the latter allows to not select any items at all while a single
// selection listbox is supposed to always have a selection (at least
// once the user selected something, it might not have any initially).
mode = GTK_SELECTION_BROWSE;
}
GtkTreeSelection* selection = gtk_tree_view_get_selection( m_treeview );
gtk_tree_selection_set_mode( selection, mode );
// Handle sortable stuff
if(HasFlag(wxLB_SORT))
{
// Setup sorting in ascending (wx) order
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(m_liststore),
WXLISTBOX_DATACOLUMN,
GTK_SORT_ASCENDING);
// Set the sort callback
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(m_liststore),
WXLISTBOX_DATACOLUMN,
(GtkTreeIterCompareFunc) gtk_listbox_sort_callback,
this, //userdata
NULL //"destroy notifier"
);
}
gtk_container_add (GTK_CONTAINER (m_widget), GTK_WIDGET(m_treeview) );
gtk_widget_show( GTK_WIDGET(m_treeview) );
m_focusWidget = GTK_WIDGET(m_treeview);
Append(n, choices); // insert initial items
// generate dclick events
g_signal_connect_after(m_treeview, "row-activated",
G_CALLBACK(gtk_listbox_row_activated_callback), this);
// for intercepting dclick generation by <ENTER>
g_signal_connect (m_treeview, "key_press_event",
G_CALLBACK (gtk_listbox_key_press_callback),
this);
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size); // need this too because this is a wxControlWithItems
g_signal_connect_after (selection, "changed",
G_CALLBACK (gtk_listitem_changed_callback), this);
return true;
}
static void
egg_tray_manager_handle_dock_request(EggTrayManager *manager,
XClientMessageEvent *xevent)
{
GtkWidget *socket;
Window *window;
ENTER;
socket = gtk_socket_new ();
gtk_widget_set_app_paintable (socket, TRUE);
gtk_widget_set_double_buffered (socket, FALSE);
gtk_widget_add_events (socket, GDK_EXPOSURE_MASK);
g_signal_connect (socket, "realize",
G_CALLBACK (egg_tray_manager_make_socket_transparent), NULL);
g_signal_connect (socket, "expose_event",
G_CALLBACK (egg_tray_manager_socket_exposed), NULL);
g_signal_connect_after (socket, "style_set",
G_CALLBACK (egg_tray_manager_socket_style_set), NULL);
gtk_widget_show (socket);
/* We need to set the child window here
* so that the client can call _get functions
* in the signal handler
*/
window = g_new (Window, 1);
*window = xevent->data.l[2];
DBG("plug window %lx\n", *window);
g_object_set_data_full (G_OBJECT (socket), "egg-tray-child-window",
window, g_free);
g_signal_emit(manager, manager_signals[TRAY_ICON_ADDED], 0,
socket);
/* Add the socket only if it's been attached */
if (GTK_IS_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(socket)))) {
GtkRequisition req;
XWindowAttributes wa;
DBG("socket has window. going on\n");
gtk_socket_add_id(GTK_SOCKET (socket), xevent->data.l[2]);
g_signal_connect(socket, "plug_removed",
G_CALLBACK(egg_tray_manager_plug_removed), manager);
gdk_error_trap_push();
XGetWindowAttributes(GDK_DISPLAY(), *window, &wa);
if (gdk_error_trap_pop()) {
ERR("can't embed window %lx\n", xevent->data.l[2]);
goto error;
}
g_hash_table_insert(manager->socket_table,
GINT_TO_POINTER(xevent->data.l[2]), socket);
req.width = req.height = 1;
gtk_widget_size_request(socket, &req);
RET();
}
error:
DBG("socket has NO window. destroy it\n");
g_signal_emit(manager, manager_signals[TRAY_ICON_REMOVED], 0,
socket);
gtk_widget_destroy(socket);
RET();
}
static void
on_active_window_changed (WnckScreen *screen,
WnckWindow *old_window,
TaskTitle *title)
{
g_return_if_fail (TASK_IS_TITLE (title));
WnckWindow *act_window = wnck_screen_get_active_window (screen);
WnckWindowType type = WNCK_WINDOW_NORMAL;
TaskTitlePrivate *priv = title->priv;
if (act_window)
type = wnck_window_get_window_type (act_window);
disconnect_window (title);
// Depending on the type and state of the window we adjust the title
if(WNCK_IS_WINDOW(act_window)) {
if(type == WNCK_WINDOW_DESKTOP) {
/* The current window is the desktop so we show the home title if
* the user has configured this, otherwise we hide the title */
if (window_picker_applet_get_show_home_title (priv->windowPickerApplet)) {
show_home_title(title);
} else {
hide_title (title);
}
} else if(wnck_window_is_skip_tasklist (act_window)
&& type != WNCK_WINDOW_DESKTOP)
{
/* The current window is not in the task list, we dont change the
* current title. */
return;
} else if(type == WNCK_WINDOW_DOCK
|| type == WNCK_WINDOW_SPLASHSCREEN
|| type == WNCK_WINDOW_MENU)
{
return;
} else { //for all other types
if(wnck_window_is_maximized (act_window) && window_picker_applet_get_show_application_title (priv->windowPickerApplet)) {
//show normal title of window
gtk_label_set_text (GTK_LABEL (priv->label),
wnck_window_get_name (act_window));
gtk_image_set_from_icon_name (GTK_IMAGE (priv->button_image),
"window-close", GTK_ICON_SIZE_MENU);
gtk_widget_set_tooltip_text (GTK_WIDGET (title),
wnck_window_get_name (act_window));
gtk_widget_set_tooltip_text (priv->button, _("Close window"));
g_signal_connect (act_window, "name-changed",
G_CALLBACK (on_name_changed), title);
g_signal_connect_after (act_window, "state-changed",
G_CALLBACK (on_state_changed), title);
gtk_widget_show (priv->grid);
priv->window = act_window;
} else {
hide_title (title); //only show the title for maximized windows
}
}
} else { //its not a window
if (task_list_get_desktop_visible (TASK_LIST (window_picker_applet_get_tasks (priv->windowPickerApplet)))
&& window_picker_applet_get_show_home_title (priv->windowPickerApplet))
{
show_home_title(title);
} else { //reset the task title and hide it
hide_title (title);
}
}
gtk_widget_queue_draw (GTK_WIDGET (title));
}
