static void
egg_find_bar_entry_populate_popup (EggFindBar *find_bar,
GtkWidget *menu)
{
GtkWidget *menu_item;
if (find_bar->priv->whole_words_only_enabled)
{
menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Whole Words Only"));
g_signal_connect (menu_item, "toggled",
G_CALLBACK (whole_words_only_toggled_callback),
find_bar);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
find_bar->priv->whole_words_only);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
}
if (find_bar->priv->case_sensitive_enabled)
{
menu_item = gtk_check_menu_item_new_with_mnemonic (_("C_ase Sensitive"));
g_signal_connect (menu_item, "toggled",
G_CALLBACK (case_sensitive_toggled_callback),
find_bar);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
find_bar->priv->case_sensitive);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
}
}
void plugin_init(GeanyData *data)
{
GeanyDocument *doc = document_get_current();
GeanyKeyGroup *group;
GtkWidget *menu;
load_config();
/* menu items and keybindings */
group = plugin_set_key_group(geany_plugin, "vimode", KB_COUNT, NULL);
menu_items.parent_item = gtk_menu_item_new_with_mnemonic(_("_Vim Mode"));
gtk_container_add(GTK_CONTAINER(geany->main_widgets->tools_menu), menu_items.parent_item);
menu = gtk_menu_new ();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_items.parent_item), menu);
menu_items.enable_vim_item = gtk_check_menu_item_new_with_mnemonic(_("Enable _Vim Mode"));
gtk_container_add(GTK_CONTAINER(menu), menu_items.enable_vim_item);
g_signal_connect((gpointer) menu_items.enable_vim_item, "activate", G_CALLBACK(on_enable_vim_mode), NULL);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_items.enable_vim_item), vi_get_enabled());
keybindings_set_item_full(group, KB_ENABLE_VIM, 0, 0, "enable_vim",
_("Enable Vim Mode"), NULL, on_enable_vim_mode_kb, NULL, NULL);
menu_items.insert_for_dummies_item = gtk_check_menu_item_new_with_mnemonic(_("Insert Mode for _Dummies"));
gtk_container_add(GTK_CONTAINER(menu), menu_items.insert_for_dummies_item);
g_signal_connect((gpointer) menu_items.insert_for_dummies_item, "activate",
G_CALLBACK(on_insert_for_dummies), NULL);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_items.insert_for_dummies_item), vi_get_insert_for_dummies());
keybindings_set_item_full(group, KB_INSERT_FOR_DUMMIES, 0, 0, "insert_for_dummies",
_("Insert Mode for Dummies"), NULL, on_insert_for_dummies_kb, NULL, NULL);
menu_items.start_in_insert_item = gtk_check_menu_item_new_with_mnemonic(_("Start in _Insert Mode"));
gtk_container_add(GTK_CONTAINER(menu), menu_items.start_in_insert_item);
g_signal_connect((gpointer) menu_items.start_in_insert_item, "activate",
G_CALLBACK(on_start_in_insert), NULL);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_items.start_in_insert_item), start_in_insert);
gtk_widget_show_all(menu_items.parent_item);
cb.on_mode_change = on_mode_change;
cb.on_save = on_save;
cb.on_save_all = on_save_all;
cb.on_quit = on_quit;
vi_init(geany_data->main_widgets->window, &cb);
vi_set_mode(start_in_insert ? VI_MODE_INSERT : VI_MODE_COMMAND);
if (doc)
vi_set_active_sci(doc->editor->sci);
}
GtkMenuItem* ContextMenuItem::createNativeMenuItem(const PlatformMenuItemDescription& menu)
{
GtkMenuItem* item = 0;
if (menu.type == SeparatorType)
item = GTK_MENU_ITEM(gtk_separator_menu_item_new());
else {
if (menu.type == CheckableActionType) {
item = GTK_MENU_ITEM(gtk_check_menu_item_new_with_mnemonic(menu.title.utf8().data()));
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), menu.checked);
} else {
if (const gchar* stockID = gtkStockIDFromContextMenuAction(menu.action)) {
item = GTK_MENU_ITEM(gtk_image_menu_item_new_with_mnemonic(menu.title.utf8().data()));
GtkWidget* image = gtk_image_new_from_stock(stockID, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
} else
item = GTK_MENU_ITEM(gtk_menu_item_new_with_mnemonic(menu.title.utf8().data()));
}
ContextMenuAction* menuAction = static_cast<ContextMenuAction*>(malloc(sizeof(ContextMenuAction*)));
*menuAction = menu.action;
g_object_set_data(G_OBJECT(item), WEBKIT_CONTEXT_MENU_ACTION, menuAction);
gtk_widget_set_sensitive(GTK_WIDGET(item), menu.enabled);
if (menu.subMenu)
gtk_menu_item_set_submenu(item, GTK_WIDGET(menu.subMenu));
}
return item;
}
void DockLet::PopupMenu(GdkEventButton *event)
{
if (!menu) {
menu = gtk_menu_new();
scan_menuitem = gtk_check_menu_item_new_with_mnemonic(_("_Scan"));
g_signal_connect(G_OBJECT(scan_menuitem), "toggled", G_CALLBACK(MenuScanCallback), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), scan_menuitem);
GtkWidget *menuitem;
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
menuitem = gtk_image_menu_item_new_with_mnemonic(_("_Quit"));
GtkWidget *image;
image = gtk_image_new_from_stock(GTK_STOCK_QUIT, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(MenuQuitCallback), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
gtk_widget_show_all(menu);
}
bool scan_selection=conf->get_bool("/apps/stardict/preferences/dictionary/scan_selection");
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(scan_menuitem),
scan_selection);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, event->button, event->time);
}
JNIEXPORT jlong JNICALL
Java_org_gnome_gtk_GtkCheckMenuItem_gtk_1check_1menu_1item_1new_1with_1mnemonic
(
JNIEnv* env,
jclass cls,
jstring _label
)
{
GtkWidget* result;
jlong _result;
const gchar* label;
// convert parameter label
label = (const gchar*) bindings_java_getString(env, _label);
if (label == NULL) {
return 0L; // Java Exception already thrown
}
// call function
result = gtk_check_menu_item_new_with_mnemonic(label);
// cleanup parameter label
bindings_java_releaseString(label);
// translate return value to JNI type
_result = (jlong) result;
// cleanup return value
if (result != NULL) {
bindings_java_memory_cleanup((GObject*)result, TRUE);
}
// and finally
return _result;
}
GtkWidget *
gul_gui_append_new_check_menuitem (GtkWidget *menu,
const char *mnemonic,
gboolean value,
GCallback callback,
gpointer data)
{
GtkWidget *menu_item;
menu_item = gtk_check_menu_item_new_with_mnemonic (mnemonic);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu),
menu_item);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item), value);
if (callback)
{
g_signal_connect (G_OBJECT (menu_item),
"activate",
callback, data);
}
return menu_item;
}
static GtkWidget *
create_tree_popup_menu (EomPluginManager *pm)
{
GtkWidget *menu;
GtkWidget *item;
GtkWidget *image;
EomPluginInfo *info;
info = plugin_manager_get_selected_plugin (pm);
if (info == NULL)
return NULL;
menu = gtk_menu_new ();
item = gtk_image_menu_item_new_with_mnemonic (_("_About"));
image = gtk_image_new_from_stock (GTK_STOCK_ABOUT,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_signal_connect (item, "activate",
G_CALLBACK (about_button_cb), pm);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_image_menu_item_new_with_mnemonic (_("C_onfigure"));
image = gtk_image_new_from_stock (GTK_STOCK_PREFERENCES,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_signal_connect (item, "activate",
G_CALLBACK (configure_button_cb), pm);
gtk_widget_set_sensitive (item,
eom_plugin_engine_plugin_is_configurable (info));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_check_menu_item_new_with_mnemonic (_("A_ctivate"));
gtk_widget_set_sensitive (item,
eom_plugin_engine_plugin_is_available (info));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
eom_plugin_engine_plugin_is_active (info));
g_signal_connect (item, "toggled",
G_CALLBACK (enable_plugin_menu_cb), pm);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_menu_item_new_with_mnemonic (_("Ac_tivate All"));
g_signal_connect (item, "activate",
G_CALLBACK (enable_all_menu_cb), pm);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
item = gtk_menu_item_new_with_mnemonic (_("_Deactivate All"));
g_signal_connect (item, "activate",
G_CALLBACK (disable_all_menu_cb), pm);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show_all (menu);
return menu;
}
GtkWidget *menu_item_add_check(GtkWidget *menu, const gchar *label, gboolean active,
GCallback func, gpointer data)
{
GtkWidget *item;
item = gtk_check_menu_item_new_with_mnemonic(label);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), active);
menu_item_finish(menu, item, func, data);
return item;
}
GtkWidget *menu_toggle_item(char *label, GtkWidget *menu, void *callback, void *userdata, int state) {
GtkWidget *item;
item = gtk_check_menu_item_new_with_mnemonic(label);
gtk_check_menu_item_set_active((GtkCheckMenuItem *) item, state);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(callback), userdata);
gtk_widget_show(item);
return item;
}
static void
w_pltbrowser_initmenu (struct ddb_gtkui_widget_s *w, GtkWidget *menu) {
GtkWidget *item;
item = gtk_check_menu_item_new_with_mnemonic (_("Show Column Headers"));
gtk_widget_show (item);
int showheaders = deadbeef->conf_get_int ("gtkui.pltbrowser.show_headers", 1);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), showheaders);
gtk_container_add (GTK_CONTAINER (menu), item);
g_signal_connect ((gpointer) item, "toggled",
G_CALLBACK (on_pltbrowser_showheaders_toggled),
w);
}
static void
add_popup_menu_items (GtkWidget *menu,
GeditViewFrame *frame)
{
GtkWidget *menu_item;
/* create "Wrap Around" menu item. */
menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Wrap Around"));
g_signal_connect (G_OBJECT (menu_item), "toggled",
G_CALLBACK (wrap_around_menu_item_toggled),
frame);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
frame->priv->wrap_around);
gtk_widget_show (menu_item);
/* create "Match Entire Word Only" menu item. */
menu_item = gtk_check_menu_item_new_with_mnemonic (_("Match _Entire Word Only"));
g_signal_connect (G_OBJECT (menu_item), "toggled",
G_CALLBACK (match_entire_word_menu_item_toggled),
frame);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
GEDIT_SEARCH_IS_ENTIRE_WORD (frame->priv->search_flags));
gtk_widget_show (menu_item);
/* create "Match Case" menu item. */
menu_item = gtk_check_menu_item_new_with_mnemonic (_("_Match Case"));
g_signal_connect (G_OBJECT (menu_item), "toggled",
G_CALLBACK (match_case_menu_item_toggled),
frame);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menu_item);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
GEDIT_SEARCH_IS_CASE_SENSITIVE (frame->priv->search_flags));
gtk_widget_show (menu_item);
}
/* Create and show the popup menu */
static void show_popup_menu(TilemDisasmView *dv, GdkEventButton *event)
{
GtkWidget *menu, *item;
dword curpos;
if (dv->popup_menu)
gtk_widget_destroy(dv->popup_menu);
dv->popup_menu = menu = gtk_menu_new();
/* Enable/disable breakpoint */
item = gtk_check_menu_item_new_with_mnemonic(_("_Breakpoint Here"));
get_cursor_line(dv, &curpos, NULL);
if (curpos == (dword) -1)
gtk_widget_set_sensitive(item, FALSE);
else if (find_line_bp(dv, curpos))
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
g_signal_connect(item, "toggled",
G_CALLBACK(toggle_bp), dv);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_widget_show(item);
item = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_widget_show(item);
/* Jump to address */
item = gtk_menu_item_new_with_mnemonic(_("_Go to Address..."));
g_signal_connect(item, "activate", G_CALLBACK(prompt_go_to), dv);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_widget_show(item);
item = gtk_menu_item_new_with_mnemonic(_("Go to P_C"));
g_signal_connect(item, "activate", G_CALLBACK(go_to_pc), dv);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_widget_show(item);
if (event)
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
event->button, event->time);
else
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, &place_menu, dv,
0, gtk_get_current_event_time());
}
static GtkWidget*
make_check_menu_item (WindowAction action,
const gchar *mnemonic_text)
{
GtkWidget *mi;
mi = gtk_check_menu_item_new_with_mnemonic (mnemonic_text);
g_signal_connect (G_OBJECT (mi), "activate",
G_CALLBACK (item_activated_callback),
GINT_TO_POINTER (action));
gtk_widget_show (mi);
return mi;
}
static GtkWidget *create_tray_menu(GtkWidget *tray_menu, int menu_type) {
GtkWidget *menu_item, *menu_image;
if ((menu_type == 1) || (menu_type == 2)) {
tray_menu = create_history_menu(tray_menu);
} else {
tray_menu = gtk_menu_new();
}
if (!prefs.use_rmb_menu || (menu_type == 2)) {
/* -------------------- */
gtk_menu_shell_append((GtkMenuShell*)tray_menu, gtk_separator_menu_item_new());
}
/* We show the options only if:
* - use_rmb_menu is active and menu_type is right-click, OR
* - use_rmb_menu is inactive and menu_type is left-click */
if ((prefs.use_rmb_menu && (menu_type == 3)) || (!prefs.use_rmb_menu) || (menu_type == 2)) {
/* Offline mode checkbox */
menu_item = gtk_check_menu_item_new_with_mnemonic(_("_Offline mode"));
gtk_check_menu_item_set_active((GtkCheckMenuItem*)menu_item, prefs.offline_mode);
g_signal_connect((GObject*)menu_item, "activate", (GCallback)toggle_offline_mode, NULL);
gtk_menu_shell_append((GtkMenuShell*)tray_menu, menu_item);
/* About */
menu_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
g_signal_connect((GObject*)menu_item, "activate", (GCallback)show_about_dialog, NULL);
gtk_menu_shell_append((GtkMenuShell*)tray_menu, menu_item);
/* Manage history */
menu_item = gtk_image_menu_item_new_with_mnemonic(_("_Manage history"));
menu_image = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image((GtkImageMenuItem*)menu_item, menu_image);
g_signal_connect((GObject*)menu_item, "activate", (GCallback)show_search, NULL);
gtk_menu_shell_append((GtkMenuShell*)tray_menu, menu_item);
/* Preferences */
menu_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_PREFERENCES, NULL);
g_signal_connect((GObject*)menu_item, "activate", (GCallback)preferences_selected, NULL);
gtk_menu_shell_append((GtkMenuShell*)tray_menu, menu_item);
/* Quit */
menu_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
g_signal_connect((GObject*)menu_item, "activate", (GCallback)quit_selected, NULL);
gtk_menu_shell_append((GtkMenuShell*)tray_menu, menu_item);
}
/* Popup the menu... */
gtk_widget_show_all(tray_menu);
return tray_menu;
}
static void gtkhash_properties_on_entry_hmac_populate_popup(GtkEntry *entry,
GtkMenu *menu)
{
GtkWidget *item;
// Add separator
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
// Add checkbutton
item = gtk_check_menu_item_new_with_mnemonic(_("_Show HMAC Key"));
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),
gtk_entry_get_visibility(entry));
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(item, "toggled", G_CALLBACK(
gtkhash_properties_on_menuitem_show_hmac_key_toggled), entry);
}
GtkWidget *
gu_menu_add_toggle(GtkWidget *parent, const char *title,
void (*cb)(GtkCheckMenuItem *menuitem, gpointer aux),
gpointer aux, gboolean active, const char *accel,
gboolean sensitive)
{
GtkWidget *w;
w = gtk_check_menu_item_new_with_mnemonic(title);
if(accel != NULL) {
gtk_menu_item_set_accel_path(GTK_MENU_ITEM(w), accel);
}
gtk_widget_set_sensitive(w, sensitive);
gtk_menu_shell_append(GTK_MENU_SHELL(parent), w);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(w), active);
g_signal_connect(G_OBJECT(w), "toggled", (void *)cb, aux);
return w;
}
static void
dmi_create_bool(dyn_menu_item_t *dmi)
{
GtkWidget *w;
if(dmi->dmi_title == NULL)
return;
assert(dmi->dmi_widget == NULL);
w = gtk_check_menu_item_new_with_mnemonic(dmi->dmi_title);
gtk_widget_set_sensitive(w, dmi->dmi_enabled);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(w), dmi->dmi_value);
gtk_widget_show(w);
gtk_menu_shell_append(GTK_MENU_SHELL(dmi->dmi_dm->dm_menu), w);
g_signal_connect(G_OBJECT(w), "toggled", (void *)dmi_toggle_cb, dmi);
dmi->dmi_widget = w;
}
static void
on_browser_populate_popup (GwhBrowser *browser,
GtkMenu *menu,
gpointer dummy)
{
GtkWidget *item;
gboolean auto_reload = FALSE;
item = gtk_separator_menu_item_new ();
gtk_widget_show (item);
gtk_menu_append (menu, item);
g_object_get (G_OBJECT (G_settings), "browser-auto-reload", &auto_reload,
NULL);
item = gtk_check_menu_item_new_with_mnemonic (_("Reload upon document saving"));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), auto_reload);
gtk_widget_show (item);
gtk_menu_append (menu, item);
g_signal_connect (item, "toggled", G_CALLBACK (on_item_auto_reload_toggled),
NULL);
}
static gboolean
toolitem_create_menu_proxy_cb (GtkToolItem *toolitem,
EphyFindToolbar *toolbar)
{
EphyFindToolbarPrivate *priv = toolbar->priv;
GtkWidget *checkbox_menu;
gboolean case_sensitive;
/* Create a menu item, and sync it */
checkbox_menu = gtk_check_menu_item_new_with_mnemonic (_("_Case sensitive"));
case_sensitive = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (priv->case_sensitive));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (checkbox_menu),
case_sensitive);
g_signal_connect (checkbox_menu, "toggled",
G_CALLBACK (case_sensitive_menu_toggled_cb), toolbar);
gtk_tool_item_set_proxy_menu_item (toolitem, "menu-proxy",
checkbox_menu);
return TRUE;
}
static GtkWidget *
empathy_contact_block_menu_item_new (EmpathyContact *contact)
{
GtkWidget *item;
EmpathyContactManager *manager;
TpConnection *connection;
EmpathyContactListFlags flags;
gboolean blocked;
g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
manager = empathy_contact_manager_dup_singleton ();
if (!empathy_contact_manager_initialized ()) {
return NULL;
}
connection = empathy_contact_get_connection (contact);
flags = empathy_contact_manager_get_flags_for_connection (manager,
connection);
if (!(flags & EMPATHY_CONTACT_LIST_CAN_BLOCK)) {
return NULL;
}
item = gtk_check_menu_item_new_with_mnemonic (_("_Block Contact"));
blocked = empathy_contact_list_get_blocked (
EMPATHY_CONTACT_LIST (manager),
contact);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), blocked);
g_signal_connect (item, "toggled",
G_CALLBACK (empathy_contact_block_menu_item_toggled),
contact);
return item;
}
RtTraceGtk::RtTraceGtk( void *tr_parent_ctx, GtkWidget *tr_parent_wid, pwr_tObjid tr_objid,
pwr_tStatus *status) :
RtTrace( tr_parent_ctx, tr_objid, status), parent_wid(tr_parent_wid), toplevel(0), nav_shell(0)
{
const int window_width = 900;
const int window_height = 800;
const int nav_width = 180;
pwr_tStatus sts;
pwr_tObjid window_objid;
pwr_tClassId cid;
char title[220];
pwr_tOName hostname;
pwr_tOName plcconnect;
pwr_tFileName fname;
sts = gdh_ObjidToName( tr_objid, name, sizeof(name), cdh_mNName);
if (EVEN(sts)) {
*status = sts;
return;
}
strcpy( title, "Trace ");
strcat( title, name);
/* Find plcwindow */
sts = gdh_GetObjectClass( tr_objid, &cid);
if ( EVEN(sts)) {
*status = sts;
return;
}
if ( !(cid == pwr_cClass_windowplc ||
cid == pwr_cClass_windowcond ||
cid == pwr_cClass_windoworderact ||
cid == pwr_cClass_windowsubstep )) {
sts = gdh_GetChild( tr_objid, &window_objid);
if ( EVEN(sts)) {
*status = sts;
return;
}
}
else
window_objid = tr_objid;
sts = gdh_GetObjectClass( window_objid, &cid);
if ( EVEN(sts)) {
*status = sts;
return;
}
if ( !(cid == pwr_cClass_windowplc ||
cid == pwr_cClass_windowcond ||
cid == pwr_cClass_windoworderact ||
cid == pwr_cClass_windowsubstep )) {
*status = 0;
return;
}
sts = get_filename( window_objid, filename, &m_has_host, hostname,
plcconnect);
if ( EVEN(sts)) {
*status = sts;
return;
}
/* Create object context */
objid = window_objid;
if ( m_has_host) {
strcpy( m_hostname, hostname);
strcpy( m_plcconnect, plcconnect);
}
char *titleutf8 = g_convert( title, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
// Gtk
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", titleutf8,
NULL);
g_free( titleutf8);
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
CoWowGtk::SetWindowIcon( toplevel);
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
// Submenu Print
GtkWidget *file_print = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Print"));
g_signal_connect( file_print, "activate",
G_CALLBACK(activate_print), this);
GtkWidget *file_print_select = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Print _Selected Documents"));
g_signal_connect( file_print_select, "activate",
G_CALLBACK(activate_printselect), this);
GtkWidget *file_savetrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Save _Trace"));
g_signal_connect( file_savetrace, "activate",
G_CALLBACK(activate_savetrace), this);
GtkWidget *file_restoretrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Restore Trace"));
g_signal_connect( file_restoretrace, "activate",
G_CALLBACK(activate_restoretrace), this);
GtkWidget *file_cleartrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("C_lear Trace"));
g_signal_connect( file_cleartrace, "activate",
G_CALLBACK(activate_cleartrace), this);
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_close), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print_select);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_savetrace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_restoretrace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_cleartrace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions Entry
GtkWidget *functions_open_object = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Open Object"));
g_signal_connect( functions_open_object, "activate",
G_CALLBACK(activate_open_object), this);
gtk_widget_add_accelerator( functions_open_object, "activate", accel_g,
'a', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_open_subwindow = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Open S_ubwindow"));
g_signal_connect( functions_open_subwindow, "activate",
G_CALLBACK(activate_open_subwindow), this);
gtk_widget_add_accelerator( functions_open_subwindow, "activate", accel_g,
'l', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_display_object = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Display object in Navigator"));
g_signal_connect( functions_display_object, "activate",
G_CALLBACK(activate_display_object), this);
gtk_widget_add_accelerator( functions_display_object, "activate", accel_g,
'd', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_show_cross = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Show Crossreferences"));
g_signal_connect( functions_show_cross, "activate",
G_CALLBACK(activate_show_cross), this);
gtk_widget_add_accelerator( functions_show_cross, "activate", accel_g,
'r', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_open_classgraph = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Open ObjectGraph"));
g_signal_connect( functions_open_classgraph, "activate",
G_CALLBACK(activate_open_classgraph), this);
gtk_widget_add_accelerator( functions_open_classgraph, "activate", accel_g,
'g', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_collect_insert = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Collect Insert"));
g_signal_connect( functions_collect_insert, "activate",
G_CALLBACK(activate_collect_insert), this);
gtk_widget_add_accelerator( functions_collect_insert, "activate", accel_g,
'v', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_object);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_subwindow);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_display_object);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_show_cross);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_classgraph);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_collect_insert);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Functions"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu));
// View Entry
GtkWidget *view_zoom_in = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect( view_zoom_in, "activate",
G_CALLBACK(activate_zoomin), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect( view_zoom_out, "activate",
G_CALLBACK(activate_zoomout), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL);
g_signal_connect( view_zoom_reset, "activate",
G_CALLBACK(activate_zoomreset), this);
gtk_widget_add_accelerator( view_zoom_reset, "activate", accel_g,
'b', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
// Submenu ScanTime
GSList *view_sc_group = NULL;
GtkWidget *view_scantime1 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.50 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime1, "activate",
G_CALLBACK(activate_scantime1), this);
GtkWidget *view_scantime2 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.20 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime2, "activate",
G_CALLBACK(activate_scantime2), this);
GtkWidget *view_scantime3 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.10 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime3, "activate",
G_CALLBACK(activate_scantime3), this);
GtkWidget *view_scantime4 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.05 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime4, "activate",
G_CALLBACK(activate_scantime4), this);
GtkWidget *view_scantime5 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.02 s");
g_signal_connect( view_scantime5, "activate",
G_CALLBACK(activate_scantime5), this);
GtkWidget *view_sc = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_ScanTime"));
GtkMenu *view_sc_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime1);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime2);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime3);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime4);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime5);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_sc),
GTK_WIDGET(view_sc_menu));
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_sc);
GtkWidget *view = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Mode entry
GSList *mode_group = NULL;
GtkWidget *mode_view = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("V_iew"));
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(mode_view));
g_signal_connect( mode_view, "activate",
G_CALLBACK(activate_view), this);
GtkWidget *mode_trace = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("_Trace"));
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(mode_trace));
g_signal_connect( mode_trace, "activate",
G_CALLBACK(activate_trace), this);
GtkWidget *mode_simulate = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("_Simulate"));
gtk_widget_add_accelerator( mode_simulate, "activate", accel_g,
's', GdkModifierType(GDK_CONTROL_MASK | GDK_SHIFT_MASK),
GTK_ACCEL_VISIBLE);
g_signal_connect( mode_simulate, "activate",
G_CALLBACK(activate_simulate), this);
GtkMenu *mode_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_view);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_trace);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_simulate);
GtkWidget *mode = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Mode"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), mode);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mode), GTK_WIDGET(mode_menu));
// Menu Help
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("On _Trace"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help),
gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
gtk_widget_add_accelerator( help_help, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *help_plcpgm = gtk_check_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("On _PlcPgm"));
g_signal_connect( help_plcpgm, "activate",
G_CALLBACK(activate_helpplc), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_plcpgm);
GtkWidget *help = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *tools_display_object = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_navigator.png");
gtk_container_add( GTK_CONTAINER(tools_display_object),
gtk_image_new_from_file( fname));
g_signal_connect(tools_display_object, "clicked", G_CALLBACK(activate_display_object), this);
gtk_toolbar_append_widget( tools, tools_display_object, "Display object in Navigator", "");
GtkWidget *tools_show_cross = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_crossref.png");
gtk_container_add( GTK_CONTAINER(tools_show_cross),
gtk_image_new_from_file( fname));
g_signal_connect(tools_show_cross, "clicked", G_CALLBACK(activate_show_cross), this);
gtk_toolbar_append_widget( tools, tools_show_cross, "Show Crossreferences", "");
GtkWidget *tools_zoom_in = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_in),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(activate_zoomin), this);
gtk_toolbar_append_widget( tools, tools_zoom_in, "Zoom in", "");
GtkWidget *tools_zoom_out = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_out),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(activate_zoomout), this);
gtk_toolbar_append_widget( tools, tools_zoom_out, "Zoom out", "");
GtkWidget *tools_zoom_reset = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_reset),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(activate_zoomreset), this);
gtk_toolbar_append_widget( tools, tools_zoom_reset, "Zoom reset", "");
// Flow widget
GtkWidget *flow_scrolled = scrolledflowwidgetgtk_new( init_flow,
this, &flow_widget);
gtk_widget_show_all(flow_widget);
nav_widget = flownavwidgetgtk_new( flow_widget);
GtkWidget *paned = gtk_hpaned_new();
gtk_paned_pack1( GTK_PANED(paned), flow_scrolled, TRUE, TRUE);
gtk_paned_pack2( GTK_PANED(paned), nav_widget, FALSE, TRUE);
GtkWidget *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), GTK_WIDGET(tools), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(paned), TRUE, TRUE, 0);
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all( toplevel);
gtk_paned_set_position( GTK_PANED(paned), window_width - nav_width);
#if 0
// Navigator window
nav_shell = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 200,
"default-width", 200,
"title", "Navigator",
NULL);
g_signal_connect( nav_shell, "delete_event", G_CALLBACK(nav_delete_event), this);
nav_widget = flownavwidgetgtk_new( flow_widget);
gtk_container_add( GTK_CONTAINER(nav_shell), nav_widget);
gtk_widget_show_all( nav_shell);
#endif
wow = new CoWowGtk( toplevel);
trace_timerid = wow->timer_new();
viewsetup();
flow_Open( flow_ctx, filename);
gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( mode_trace), TRUE);
gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( view_scantime1), TRUE);
//trasetup();
//trace_start();
#if defined OS_LINUX
{
struct stat info;
if ( stat( filename, &info) != -1)
version = info.st_ctime;
}
#endif
// Check version
unsigned int flow_version;
pwr_tUInt32 window_version;
pwr_tAName aname;
flow_GetCtxUserVersion( flow_ctx, &flow_version);
strcpy( aname, name);
strcat( aname, ".Version");
sts = gdh_GetObjectInfo( aname, &window_version, sizeof(window_version));
if ( EVEN(sts)) return;
if ( flow_version > window_version)
wow->DisplayError( "Version mismatch", "Trace file is newer than database version");
else if ( flow_version < window_version)
wow->DisplayError( "Version mismatch", "Trace file is older than database version");
}
static void setup_view(GtkWidget* view)
{
GtkListStore* store = gtk_list_store_new (23,
G_TYPE_STRING, /* 0 Country */
G_TYPE_STRING, /* 1 Good Name */
GDK_TYPE_PIXBUF, /* 2 NULL for Status handle / empty */
G_TYPE_STRING, /* 3 User Comments */
G_TYPE_STRING, /* 4 File Name */
G_TYPE_STRING, /* 5 MD5 Hash */
G_TYPE_STRING, /* 6 CRC1 */
G_TYPE_STRING, /* 7 CRC2 */
G_TYPE_STRING, /* 8 Internal Name */
G_TYPE_STRING, /* 9 Save Type */
G_TYPE_STRING, /* 10 Players */
G_TYPE_STRING, /* 11 Size */
G_TYPE_STRING, /* 12 Compression */
G_TYPE_STRING, /* 13 Image Type */
G_TYPE_STRING, /* 14 CIC Chip */
G_TYPE_STRING, /* 15 Rumble */
GDK_TYPE_PIXBUF, /* 16-20 Pixbufs for Status stars. */
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF,
GDK_TYPE_PIXBUF, /* 21 Flag */
G_TYPE_POINTER, /* 22 RCS Entry */
-1);
GtkCellRenderer* renderer;
GtkTreeViewColumn* column;
GtkWidget* item;
char buffer[128];
int i;
unsigned char visible;
/* Create country flag / string dual rendered cell. */
renderer = gtk_cell_renderer_pixbuf_new();
g_MainWindow.column[0] = gtk_tree_view_column_new();
column = g_MainWindow.column[0];
gtk_tree_view_column_set_title(column, g_MainWindow.column_names[0][0]);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 21);
g_object_set(renderer, "xpad", 5, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, 0);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 0);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
renderer = gtk_cell_renderer_text_new();
g_MainWindow.column[1] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[1][0], renderer, "text", 1, NULL);
column = g_MainWindow.column[1];
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, 1);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 1);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
/* Status stars. */
g_MainWindow.column[2] = gtk_tree_view_column_new();
column = g_MainWindow.column[2];
gtk_tree_view_column_set_title(column, g_MainWindow.column_names[2][0]);
renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(renderer, "xpad", 2, NULL);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2);
for(i = 0; i < 5; ++i)
{
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 16+i);
}
renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(renderer, "xpad", 2, NULL);
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", 2);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, 2);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, 2);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
for(i = 3; i < 16; ++i)
{
renderer = gtk_cell_renderer_text_new();
g_MainWindow.column[i] = gtk_tree_view_column_new_with_attributes(g_MainWindow.column_names[i][0], renderer, "text", i, NULL);
column = g_MainWindow.column[i];
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_reorderable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, i);
gtk_tree_view_insert_column(GTK_TREE_VIEW (view), column, i);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
}
renderer = gtk_cell_renderer_text_new ();
g_MainWindow.column[16] = gtk_tree_view_column_new();
column = g_MainWindow.column[16];
gtk_tree_view_column_set_visible(column, FALSE);
gtk_tree_view_insert_column(GTK_TREE_VIEW(view), column, 2);
g_signal_connect(column->button, "button-press-event", G_CALLBACK(callback_header_clicked), column);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
g_MainWindow.romHeaderMenu = gtk_menu_new();
/* Toggle column visibility from config file, make menu. */
for(i = 0; i < 16; ++i)
{
snprintf(buffer, sizeof(buffer), " %s", g_MainWindow.column_names[i][0]);
item = gtk_check_menu_item_new_with_mnemonic(buffer);
if((visible=config_get_bool(g_MainWindow.column_names[i][1], 2))==2)
{
visible = (i<5) ? TRUE: FALSE;
config_put_bool(g_MainWindow.column_names[i][1], visible);
}
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), visible);
gtk_tree_view_column_set_visible(g_MainWindow.column[i], visible);
gtk_menu_shell_append(GTK_MENU_SHELL(g_MainWindow.romHeaderMenu), item);
g_signal_connect(item, "activate", G_CALLBACK(callback_column_visible), GUINT_TO_POINTER(i));
}
gtk_tree_view_column_set_visible(g_MainWindow.column[16], FALSE);
for(i = 0; i < 16; ++i)
{
if(gtk_tree_view_column_get_visible(GTK_TREE_VIEW_COLUMN(g_MainWindow.column[i])))
return;
}
gtk_tree_view_column_set_visible(g_MainWindow.column[16], TRUE);
}
GtkWidget *
mate_panel_applet_create_menu (AppletInfo *info)
{
GtkWidget *menu;
GtkWidget *menuitem;
GList *l;
PanelWidget *panel_widget;
gboolean added_anything = FALSE;
panel_widget = mate_panel_applet_get_panel_widget (info);
menu = g_object_ref_sink (gtk_menu_new ());
/* connect the show & deactivate signal, so that we can "disallow" and
* "re-allow" autohide when the menu is shown/deactivated.
*/
g_signal_connect (menu, "show",
G_CALLBACK (applet_menu_show), info);
g_signal_connect (menu, "deactivate",
G_CALLBACK (applet_menu_deactivate), info);
for (l = info->user_menu; l; l = l->next) {
AppletUserMenu *user_menu = l->data;
if (user_menu->is_enabled_func && !user_menu->is_enabled_func ())
continue;
add_to_submenus (info, "", user_menu->name, user_menu,
menu, info->user_menu);
added_anything = TRUE;
}
if (!panel_lockdown_get_locked_down ()) {
GtkWidget *image;
gboolean locked;
gboolean lockable;
gboolean movable;
gboolean removable;
lockable = mate_panel_applet_lockable (info);
movable = mate_panel_applet_can_freely_move (info);
removable = panel_profile_id_lists_are_writable ();
locked = panel_widget_get_applet_locked (panel_widget, info->widget);
if (added_anything) {
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Remove From Panel"));
image = gtk_image_new_from_stock (GTK_STOCK_REMOVE,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
image);
g_signal_connect (menuitem, "activate",
G_CALLBACK (applet_remove_callback), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, (!locked || lockable) && removable);
menuitem = gtk_menu_item_new_with_mnemonic (_("_Move"));
g_signal_connect (menuitem, "activate",
G_CALLBACK (move_applet_callback), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, !locked && movable);
g_assert (info->move_item == NULL);
info->move_item = menuitem;
g_object_add_weak_pointer (G_OBJECT (menuitem),
(gpointer *) &info->move_item);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_check_menu_item_new_with_mnemonic (_("Loc_k To Panel"));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
locked);
g_signal_connect (menuitem, "toggled",
G_CALLBACK (mate_panel_applet_lock), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, lockable);
added_anything = TRUE;
}
if ( ! added_anything) {
g_object_unref (menu);
return NULL;
}
return menu;
}
GeCurveGtk::GeCurveGtk( void *gc_parent_ctx,
GtkWidget *parent_widget,
char *curve_name,
char *filename,
GeCurveData *curve_data,
int pos_right,
int gc_width,
int gc_height,
unsigned int gc_options,
int gc_color_theme,
void *basewidget) :
GeCurve( gc_parent_ctx, curve_name, filename, curve_data, pos_right,
gc_width, gc_height, gc_options, gc_color_theme),
minmax_widget(0), export_widget(0), disable_timecombo_callback(0), clock_cursor(0)
{
int window_width = 900;
int window_height = 700;
const int names_height = 150;
const int nav_height = 120;
pwr_tFileName fname;
float height_scale = 1;
int nonav = 0;
if ( gc_width != 0)
window_width = gc_width;
if ( gc_height != 0) {
height_scale = (float)gc_height / window_height;
window_height = gc_height;
}
cdh_StrncpyCutOff( title, curve_name, sizeof(title), 1);
// Gtk
if ( !(options & curve_mOptions_Embedded)) {
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", CoWowGtk::convert_utf8(title),
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);
}
else {
toplevel = parent_widget;
}
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
menu_add = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Add"));
g_signal_connect( menu_add, "activate",
G_CALLBACK(activate_madd), this);
GtkWidget *file_refresh = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Refresh"));
g_signal_connect( file_refresh, "activate",
G_CALLBACK(activate_configure), this);
gtk_widget_add_accelerator( file_refresh, "activate", accel_g, 'r', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *file_print = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Print"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_print),
gtk_image_new_from_stock( "gtk-print", GTK_ICON_SIZE_MENU));
g_signal_connect(file_print, "activate", G_CALLBACK(activate_print), this);
menu_export = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Export"));
g_signal_connect(menu_export, "activate", G_CALLBACK(activate_export), this);
menu_new = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_New"));
g_signal_connect(menu_new, "activate", G_CALLBACK(activate_new), this);
menu_save = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("S_ave"));
g_signal_connect(menu_save, "activate", G_CALLBACK(activate_save), this);
gtk_widget_add_accelerator( menu_save, "activate", accel_g,'s',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
menu_open = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Open"));
g_signal_connect(menu_open, "activate", G_CALLBACK(activate_open), this);
menu_snapshot = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Snapshot"));
g_signal_connect(menu_snapshot, "activate", G_CALLBACK(activate_snapshot), this);
gtk_widget_add_accelerator( menu_snapshot, "activate", accel_g,'n',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkWidget *file_close = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Close"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_close),
gtk_image_new_from_stock( "gtk-close", GTK_ICON_SIZE_MENU));
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
gtk_widget_add_accelerator( file_close, "activate", accel_g,'w', 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), menu_add);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_refresh);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_new);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_open);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_save);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_snapshot);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), menu_export);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// View menu
GtkWidget *view_zoom_in = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _In"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_in),
gtk_image_new_from_stock( "gtk-zoom-in", GTK_ICON_SIZE_MENU));
g_signal_connect(view_zoom_in, "activate", G_CALLBACK(activate_zoomin), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Out"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_out),
gtk_image_new_from_stock( "gtk-zoom-out", GTK_ICON_SIZE_MENU));
g_signal_connect(view_zoom_out, "activate", G_CALLBACK(activate_zoomout), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Reset"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_reset),
gtk_image_new_from_stock( "gtk-zoom-100", GTK_ICON_SIZE_MENU));
g_signal_connect(view_zoom_reset, "activate", G_CALLBACK(activate_zoomreset), this);
GtkWidget *view_background = gtk_check_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Background Color"));
g_signal_connect( view_background, "activate",
G_CALLBACK(activate_background), this);
GtkWidget *view_showname = gtk_check_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Show Names"));
g_signal_connect( view_showname, "activate",
G_CALLBACK(activate_showname), this);
gtk_widget_add_accelerator( view_showname, "activate", accel_g,
'w', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_filledcurves = gtk_check_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Filled Curves"));
g_signal_connect( view_filledcurves, "activate",
G_CALLBACK(activate_filledcurves), this);
GtkWidget *view_xlimits = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_X-Axis Limits"));
g_signal_connect( view_xlimits, "activate",
G_CALLBACK(activate_xlimits), this);
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_background);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_showname);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_filledcurves);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_xlimits);
GtkWidget *view = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Menu Help
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help),
gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
gtk_widget_add_accelerator( help_help, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
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(CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *tools_zoom_in = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_in),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(activate_zoomin), this);
g_object_set( tools_zoom_in, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_in, CoWowGtk::translate_utf8("Zoom in"), "");
GtkWidget *tools_zoom_out = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_out),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(activate_zoomout), this);
g_object_set( tools_zoom_out, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_out, CoWowGtk::translate_utf8("Zoom out"), "");
GtkWidget *tools_zoom_reset = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_reset),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(activate_zoomreset), this);
g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_reset, CoWowGtk::translate_utf8("Zoom reset"), "");
GtkWidget *tools_page_left = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_page_left.png");
gtk_container_add( GTK_CONTAINER(tools_page_left),
gtk_image_new_from_file( fname));
g_signal_connect(tools_page_left, "clicked", G_CALLBACK(activate_page_left), this);
g_object_set( tools_page_left, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_page_left, CoWowGtk::translate_utf8("Page left"), "");
GtkWidget *tools_scroll_left = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_scroll_left.png");
gtk_container_add( GTK_CONTAINER(tools_scroll_left),
gtk_image_new_from_file( fname));
g_signal_connect(tools_scroll_left, "clicked", G_CALLBACK(activate_scroll_left), this);
g_object_set( tools_scroll_left, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_scroll_left, CoWowGtk::translate_utf8("Scroll left"), "");
GtkWidget *tools_scroll_right = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_scroll_right.png");
gtk_container_add( GTK_CONTAINER(tools_scroll_right),
gtk_image_new_from_file( fname));
g_signal_connect(tools_scroll_right, "clicked", G_CALLBACK(activate_scroll_right), this);
g_object_set( tools_scroll_right, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_scroll_right, CoWowGtk::translate_utf8("Scroll right"), "");
GtkWidget *tools_page_right = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_page_right.png");
gtk_container_add( GTK_CONTAINER(tools_page_right),
gtk_image_new_from_file( fname));
g_signal_connect(tools_page_right, "clicked", G_CALLBACK(activate_page_right), this);
g_object_set( tools_page_right, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_page_right, CoWowGtk::translate_utf8("Page right"), "");
tools_snapshot = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_snapshot.png");
gtk_container_add( GTK_CONTAINER(tools_snapshot),
gtk_image_new_from_file( fname));
g_signal_connect(tools_snapshot, "clicked", G_CALLBACK(activate_snapshot), this);
g_object_set( tools_snapshot, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_snapshot, CoWowGtk::translate_utf8("Snapshot"), "");
tools_add = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_add.png");
gtk_container_add( GTK_CONTAINER(tools_add),
gtk_image_new_from_file( fname));
g_signal_connect(tools_add, "clicked", G_CALLBACK(activate_add), this);
g_object_set( tools_add, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_add, CoWowGtk::translate_utf8("Add"), "");
// Time box
GtkToolbar *timetools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *sea_time_start_label = gtk_label_new( CoWowGtk::translate_utf8("Time"));
gtk_widget_set_size_request( sea_time_start_label, 70, -1);
gtk_misc_set_alignment( GTK_MISC(sea_time_start_label), 0.0, 0.5);
gtk_toolbar_append_widget( timetools, sea_time_start_label, "", "");
// Time option menu
timebox_timecombo = gtk_combo_box_new_text();
for ( int i = 0; curve_timecombo_text[i].text[0]; i++)
gtk_combo_box_append_text( GTK_COMBO_BOX(timebox_timecombo),
CoWowGtk::translate_utf8(curve_timecombo_text[i].text));
g_signal_connect(timebox_timecombo, "changed", G_CALLBACK(activate_timecombo), this);
gtk_toolbar_append_widget( timetools, timebox_timecombo, 0, "");
timebox_start_time = gtk_entry_new();
gtk_widget_set_size_request( timebox_start_time, 160, -1);
gtk_toolbar_append_widget( timetools, timebox_start_time, "", "");
GtkWidget *sea_time_stop_label = gtk_label_new( CoWowGtk::translate_utf8("-"));
gtk_widget_set_size_request( sea_time_stop_label, 20, -1);
gtk_toolbar_append_widget( timetools, sea_time_stop_label, "", "");
timebox_stop_time = gtk_entry_new();
gtk_widget_set_size_request( timebox_stop_time, 160, -1);
gtk_toolbar_append_widget( timetools, timebox_stop_time, "", "");
GtkWidget *timebox_prev_period = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_scroll_left.png");
gtk_container_add( GTK_CONTAINER(timebox_prev_period),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_prev_period, "clicked", G_CALLBACK(activate_prev_period), this);
g_object_set( timebox_prev_period, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( timetools, timebox_prev_period, CoWowGtk::translate_utf8("Previous period"), "");
GtkWidget *timebox_next_period = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_scroll_right.png");
gtk_container_add( GTK_CONTAINER(timebox_next_period),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_next_period, "clicked", G_CALLBACK(activate_next_period), this);
g_object_set( timebox_next_period, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( timetools, timebox_next_period, CoWowGtk::translate_utf8("Next period"), "");
GtkWidget *timebox_increase_period = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_up.png");
gtk_container_add( GTK_CONTAINER(timebox_increase_period),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_increase_period, "clicked", G_CALLBACK(activate_increase_period), this);
g_object_set( timebox_increase_period, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( timetools, timebox_increase_period, CoWowGtk::translate_utf8("Increase period"), "");
GtkWidget *timebox_decrease_period = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_down.png");
gtk_container_add( GTK_CONTAINER(timebox_decrease_period),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_decrease_period, "clicked", G_CALLBACK(activate_decrease_period), this);
g_object_set( timebox_decrease_period, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( timetools, timebox_decrease_period, CoWowGtk::translate_utf8("Decrease period"), "");
GtkWidget *timebox_reload = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/ge_reload.png");
gtk_container_add( GTK_CONTAINER(timebox_reload),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_reload, "clicked", G_CALLBACK(activate_reload), this);
g_object_set( timebox_reload, "can-focus", FALSE, NULL);
// gtk_toolbar_append_widget( timetools, timebox_reload, CoWowGtk::translate_utf8("Update"), "");
GtkWidget *timebox_add = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_add.png");
gtk_container_add( GTK_CONTAINER(timebox_add),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_add, "clicked", G_CALLBACK(activate_add), this);
g_object_set( timebox_add, "can-focus", FALSE, NULL);
// gtk_toolbar_append_widget( timetools, timebox_add, CoWowGtk::translate_utf8("Add curve item"), "");
GtkWidget *timebox_remove = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_remove.png");
gtk_container_add( GTK_CONTAINER(timebox_remove),
gtk_image_new_from_file( fname));
g_signal_connect(timebox_remove, "clicked", G_CALLBACK(activate_remove), this);
g_object_set( timebox_remove, "can-focus", FALSE, NULL);
// gtk_toolbar_append_widget( timetools, timebox_remove, CoWowGtk::translate_utf8("Remove selected curve"), "");
GtkToolbar *curvebuttonbox = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
//GtkWidget *curvebuttonbox = gtk_hbox_new( FALSE, 0);
gtk_toolbar_append_widget( curvebuttonbox, timebox_reload, CoWowGtk::translate_utf8("Update curve"), "");
gtk_toolbar_append_widget( curvebuttonbox, timebox_add, CoWowGtk::translate_utf8("Add curve item"), "");
sea_timebox = gtk_hbox_new( FALSE, 0);
// gtk_box_pack_start( GTK_BOX(sea_timebox), sea_time_start_label, FALSE, FALSE, 0);
// gtk_box_pack_start( GTK_BOX(sea_timebox), timebox_timecombo, FALSE, FALSE, 10);
// gtk_box_pack_start( GTK_BOX(sea_timebox), timebox_start_time, FALSE, FALSE, 0);
// gtk_box_pack_start( GTK_BOX(sea_timebox), sea_time_stop_label, FALSE, FALSE, 0);
// gtk_box_pack_start( GTK_BOX(sea_timebox), timebox_stop_time, FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(sea_timebox), GTK_WIDGET(timetools), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(sea_timebox), gtk_hseparator_new(), FALSE, FALSE, 10);
gtk_box_pack_start( GTK_BOX(sea_timebox), GTK_WIDGET(curvebuttonbox), FALSE, FALSE, 0);
GtkWidget *w;
grownames_main_widget = scrolledgrowwidgetgtk_new( init_grownames_cb, this, &w);
if ( nonav)
growcurve_main_widget = scrolledcurvewidgetgtk_new( init_growcurve_cb, this, &w);
else
growcurve_main_widget = curvewidgetgtk_new( init_growcurve_cb, this);
growaxis_main_widget = growwidgetgtk_new( init_growaxis_cb, this);
if (!nonav)
nav_widget = curvenavwidgetgtk_new( growcurve_main_widget);
GtkWidget *hbox = gtk_hbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(hbox), growaxis_main_widget, FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(hbox), growcurve_main_widget, TRUE, TRUE, 0);
gtk_widget_show_all( hbox);
GtkWidget *vpaned1 = gtk_vpaned_new();
GtkWidget *vpaned2 = gtk_vpaned_new();
gtk_paned_add1( GTK_PANED(vpaned1), grownames_main_widget);
gtk_paned_add2( GTK_PANED(vpaned1), vpaned2);
gtk_widget_show_all( vpaned1);
gtk_paned_pack1( GTK_PANED(vpaned2), hbox, TRUE, TRUE);
if ( !nonav)
gtk_paned_pack2( GTK_PANED(vpaned2), nav_widget, FALSE, TRUE);
gtk_widget_show_all( vpaned2);
GtkWidget *tools_box = gtk_hbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(tools_box), GTK_WIDGET(tools), FALSE, FALSE, 0);
// gtk_box_pack_start( GTK_BOX(tools_box), GTK_WIDGET(sea_timebox), FALSE, FALSE, 0);
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), GTK_WIDGET(tools_box), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(sea_timebox), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(vpaned1), TRUE, TRUE, 0);
if ( !(options & curve_mOptions_Embedded)) {
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all( toplevel);
}
else
gtk_widget_set_size_request( vbox, window_width, window_height);
gtk_paned_set_position( GTK_PANED(vpaned1), names_height * height_scale);
gtk_paned_set_position( GTK_PANED(vpaned2), (window_height - names_height - nav_height - 50) * height_scale);
g_object_set( sea_timebox, "visible", FALSE, NULL);
g_object_set( menu_new, "visible", FALSE, NULL);
g_object_set( menu_save, "visible", FALSE, NULL);
g_object_set( menu_open, "visible", FALSE, NULL);
g_object_set( menu_snapshot, "visible", FALSE, NULL);
g_object_set( menu_export, "visible", FALSE, NULL);
g_object_set( tools_snapshot, "visible", FALSE, NULL);
g_object_set( tools_add, "visible", FALSE, NULL);
wow = new CoWowGtk( toplevel);
gtk_combo_box_set_active( GTK_COMBO_BOX(timebox_timecombo), 2);
if ( !(options & curve_mOptions_Embedded)) {
if ( options & curve_mOptions_FullScreen)
gtk_window_fullscreen( GTK_WINDOW(toplevel));
else if ( options & curve_mOptions_Maximize)
gtk_window_maximize( GTK_WINDOW(toplevel)); // TODO
else if ( options & curve_mOptions_FullMaximize)
gtk_window_maximize( GTK_WINDOW(toplevel));
else if ( options & curve_mOptions_Iconify)
gtk_window_iconify( GTK_WINDOW(toplevel));
else if ( options & curve_mOptions_Invisible)
g_object_set( toplevel, "visible", FALSE, NULL);
if ( basewidget)
gtk_window_set_transient_for(GTK_WINDOW(toplevel), GTK_WINDOW(basewidget));
}
}
static gboolean
gtk_toggle_tool_button_create_menu_proxy (GtkToolItem *item)
{
GtkToolButton *tool_button = GTK_TOOL_BUTTON (item);
GtkToggleToolButton *toggle_tool_button = GTK_TOGGLE_TOOL_BUTTON (item);
GtkWidget *menu_item = NULL;
GtkStockItem stock_item;
gboolean use_mnemonic = TRUE;
const char *label;
GtkWidget *label_widget;
const gchar *label_text;
const gchar *stock_id;
if (_gtk_tool_item_create_menu_proxy (item))
return TRUE;
label_widget = gtk_tool_button_get_label_widget (tool_button);
label_text = gtk_tool_button_get_label (tool_button);
stock_id = gtk_tool_button_get_stock_id (tool_button);
if (GTK_IS_LABEL (label_widget))
{
label = gtk_label_get_label (GTK_LABEL (label_widget));
use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (label_widget));
}
else if (label_text)
{
label = label_text;
use_mnemonic = gtk_tool_button_get_use_underline (tool_button);
}
else if (stock_id && gtk_stock_lookup (stock_id, &stock_item))
{
label = stock_item.label;
}
else
{
label = "";
}
if (use_mnemonic)
menu_item = gtk_check_menu_item_new_with_mnemonic (label);
else
menu_item = gtk_check_menu_item_new_with_label (label);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
toggle_tool_button->priv->active);
if (GTK_IS_RADIO_TOOL_BUTTON (toggle_tool_button))
{
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (menu_item),
TRUE);
}
g_signal_connect_closure_by_id (menu_item,
g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
g_cclosure_new_object (G_CALLBACK (menu_item_activated),
G_OBJECT (toggle_tool_button)),
FALSE);
gtk_tool_item_set_proxy_menu_item (item, MENU_ID, menu_item);
return TRUE;
}
/**
* @brief Instance initializer function for the \e GtkExperimentTranscript widget
*
* @param klass Newly constructed \e GtkExperimentTranscript instance
*/
static void
gtk_experiment_transcript_init(GtkExperimentTranscript *klass)
{
GtkWidget *item, *submenu, *image;
klass->priv = GTK_EXPERIMENT_TRANSCRIPT_GET_PRIVATE(klass);
klass->speaker = NULL;
klass->interactive_format.default_font = NULL;
klass->interactive_format.default_text_color = NULL;
klass->interactive_format.default_bg_color = NULL;
klass->priv->flag_mask = 0;
klass->priv->time_adjustment = gtk_adjustment_new(0., 0., 0.,
0., 0., 0.);
g_object_ref_sink(klass->priv->time_adjustment);
klass->priv->time_adj_on_value_changed_id =
g_signal_connect(G_OBJECT(klass->priv->time_adjustment),
"value-changed",
G_CALLBACK(time_adj_on_value_changed), klass);
klass->priv->layer_text = NULL;
klass->priv->layer_text_layout =
gtk_widget_create_pango_layout(GTK_WIDGET(klass), NULL);
pango_layout_set_wrap(klass->priv->layer_text_layout, PANGO_WRAP_WORD_CHAR);
pango_layout_set_ellipsize(klass->priv->layer_text_layout, PANGO_ELLIPSIZE_END);
klass->priv->backdrop.start = 0;
klass->priv->backdrop.end = 0;
klass->priv->contribs = NULL;
klass->priv->formats = NULL;
klass->priv->interactive_format.regexp = NULL;
klass->priv->interactive_format.attribs = NULL;
/** @todo It should be possible to reset font and colors (to widget defaults) */
klass->priv->menu = gtk_menu_new();
gtk_menu_attach_to_widget(GTK_MENU(klass->priv->menu),
GTK_WIDGET(klass), NULL);
item = gtk_image_menu_item_new_with_mnemonic("Choose _Font...");
image = gtk_image_new_from_stock(GTK_STOCK_SELECT_FONT,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
g_signal_connect(item, "activate",
G_CALLBACK(choose_font_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
gtk_widget_show(item);
item = gtk_image_menu_item_new_with_mnemonic("Choose _Text Color...");
image = gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
g_signal_connect(item, "activate",
G_CALLBACK(choose_text_color_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
gtk_widget_show(item);
item = gtk_image_menu_item_new_with_mnemonic("Choose _Background Color...");
image = gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
g_signal_connect(item, "activate",
G_CALLBACK(choose_bg_color_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
gtk_widget_show(item);
submenu = gtk_menu_new();
item = gtk_menu_item_new_with_label("Text Alignment");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
gtk_widget_show(item);
/*
* position in alignment_group list corresponds with PangoAlignment
* (PANGO_ALIGN_RIGHT, PANGO_ALIGN_CENTER, PANGO_ALIGN_LEFT)
*/
item = gtk_radio_menu_item_new_with_mnemonic(NULL, "_Left");
klass->priv->alignment_group =
gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
g_signal_connect(item, "activate",
G_CALLBACK(text_alignment_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
item = gtk_radio_menu_item_new_with_mnemonic(klass->priv->alignment_group,
"_Center");
klass->priv->alignment_group =
gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
g_signal_connect(item, "activate",
G_CALLBACK(text_alignment_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
item = gtk_radio_menu_item_new_with_mnemonic(klass->priv->alignment_group,
"_Right");
klass->priv->alignment_group =
gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
g_signal_connect(item, "activate",
G_CALLBACK(text_alignment_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
gtk_widget_show_all(submenu);
gtk_experiment_transcript_set_alignment(klass, PANGO_ALIGN_LEFT);
item = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
gtk_widget_show(item);
klass->priv->menu_reverse_item =
gtk_check_menu_item_new_with_mnemonic("_Reverse");
g_signal_connect(klass->priv->menu_reverse_item, "activate",
G_CALLBACK(reverse_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu),
klass->priv->menu_reverse_item);
gtk_widget_show(klass->priv->menu_reverse_item);
gtk_widget_set_can_focus(GTK_WIDGET(klass), TRUE);
}
EvAlaGtk::EvAlaGtk( void *ev_parent_ctx,
GtkWidget *ev_parent_wid,
char *ala_name,
pwr_tObjid ev_user,
int ev_eventname_seg,
int ev_width,
int ev_height,
int ev_x,
int ev_y,
pwr_tObjid ev_view,
unsigned int ev_options,
void *widget,
pwr_tStatus *status) :
EvAla( ev_parent_ctx, ala_name, ev_user, ev_eventname_seg,
ev_width, ev_height, ev_x, ev_y, ev_view, ev_options, status),
parent_wid(ev_parent_wid), toplevel(0)
{
pwr_tStatus sts;
pwr_sClass_OpPlace *opp;
pwr_tFileName fname;
int ala_width = 700;
int ala_height = 300;
*status = 1;
if ( ev_width != 0 && ev_height != 0) {
ala_width = ev_width;
ala_height = ev_height;
}
// Check user object
if ( cdh_ObjidIsNull( user)) {
*status = XNAV__NOUSER;
return;
}
sts = gdh_ObjidToPointer( user, (pwr_tAddress *) &opp);
if ( EVEN(sts)) {
*status = XNAV__NOUSER;
return;
}
ala_size = opp->MaxNoOfAlarms;
// create_aliaslist( opp);
// Ala Window
if ( !(options & ev_mAlaOptions_Embedded)) {
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", ala_height,
"default-width", ala_width,
"title", CoWowGtk::translate_utf8(ala_name),
NULL);
parent_wid_ala = toplevel;
g_signal_connect( parent_wid_ala, "delete_event", G_CALLBACK(ala_delete_event), this);
g_signal_connect( parent_wid_ala, "destroy", G_CALLBACK(ala_destroy_event), this);
g_signal_connect( parent_wid_ala, "focus-in-event", G_CALLBACK(ala_action_inputfocus), this);
CoWowGtk::SetWindowIcon( parent_wid_ala);
}
else
parent_wid_ala = (GtkWidget *)widget;
ala_vbox = gtk_vbox_new( FALSE, 0);
// Menu
// Accelerators
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(parent_wid_ala), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File entry
GtkWidget *file_print = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Print"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_print),
gtk_image_new_from_stock( "gtk-print", GTK_ICON_SIZE_MENU));
g_signal_connect(file_print, "activate", G_CALLBACK(ala_activate_print), this);
GtkWidget *file_close = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Close"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_close),
gtk_image_new_from_stock( "gtk-close", GTK_ICON_SIZE_MENU));
g_signal_connect(file_close, "activate", G_CALLBACK(ala_activate_exit), this);
gtk_widget_add_accelerator( file_close, "activate", accel_g,
'w', 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_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions entry
GtkWidget *functions_ack_last = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Acknowledge"));
g_signal_connect( functions_ack_last, "activate",
G_CALLBACK(ala_activate_ack_last), this);
gtk_widget_add_accelerator( functions_ack_last, "activate", accel_g,
'k', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_ack_all = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("A_cknowledge All"));
g_signal_connect( functions_ack_all, "activate",
G_CALLBACK(ala_activate_ack_all), this);
GtkWidget *functions_open_plc = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Open _Program"));
g_signal_connect( functions_open_plc, "activate",
G_CALLBACK(ala_activate_open_plc), this);
gtk_widget_add_accelerator( functions_open_plc, "activate", accel_g,
'l', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_display_object = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Display object in Navigator"));
g_signal_connect( functions_display_object, "activate",
G_CALLBACK(ala_activate_display_in_xnav), this);
gtk_widget_add_accelerator( functions_display_object, "activate", accel_g,
'd', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkMenu *func_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_ack_last);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_ack_all);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_open_plc);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_display_object);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Functions"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(func_menu));
// View entry
GtkWidget *view_shift_view = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("S_hift View"));
g_signal_connect( view_shift_view, "activate",
G_CALLBACK(ala_activate_shift_view), this);
gtk_widget_add_accelerator( view_shift_view, "activate", accel_g,
'n', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_in = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _In"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_in),
gtk_image_new_from_stock( "gtk-zoom-in", GTK_ICON_SIZE_MENU));
g_signal_connect( view_zoom_in, "activate",
G_CALLBACK(ala_activate_zoom_in), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Out"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_out),
gtk_image_new_from_stock( "gtk-zoom-out", GTK_ICON_SIZE_MENU));
g_signal_connect( view_zoom_out, "activate",
G_CALLBACK(ala_activate_zoom_out), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Reset"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_reset),
gtk_image_new_from_stock( "gtk-zoom-100", GTK_ICON_SIZE_MENU));
g_signal_connect( view_zoom_reset, "activate",
G_CALLBACK(ala_activate_zoom_reset), this);
gtk_widget_add_accelerator( view_zoom_reset, "activate", accel_g,
'b', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_disp_hundredth = gtk_check_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Display hundredth"));
g_signal_connect( view_disp_hundredth, "activate",
G_CALLBACK(ala_activate_disp_hundredth), this);
GtkWidget *view_hide_object = gtk_check_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Hide Event Name"));
g_signal_connect( view_hide_object, "activate",
G_CALLBACK(ala_activate_hide_object), this);
GtkWidget *view_hide_text = gtk_check_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Hide _Event Text"));
g_signal_connect( view_hide_text, "activate",
G_CALLBACK(ala_activate_hide_text), this);
// Submenu Select View
GtkWidget *view_select_flat = gtk_menu_item_new_with_mnemonic( "_Flat");
g_signal_connect( view_select_flat, "activate",
G_CALLBACK(ala_activate_select_flat), this);
GtkWidget *view_select = gtk_menu_item_new_with_mnemonic( "_Select View");
GtkMenu *view_select_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_select_menu), view_select_flat);
for ( unsigned int i = 0; i < sizeof(opp->AlarmViews)/sizeof(opp->AlarmViews[0]); i++) {
pwr_sClass_AlarmView *viewp;
if ( cdh_ObjidIsNull( opp->AlarmViews[i]))
break;
sts = gdh_ObjidToPointer( opp->AlarmViews[i], (void **)&viewp);
if ( ODD(sts)) {
alarm_views[i] = opp->AlarmViews[i];
GtkWidget *view_select_view = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8(viewp->Name));
switch ( i) {
case 0: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view1), this); break;
case 1: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view2), this); break;
case 2: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view3), this); break;
case 3: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view4), this); break;
case 4: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view5), this); break;
case 5: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view6), this); break;
case 6: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view7), this); break;
case 7: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view8), this); break;
case 8: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view9), this); break;
case 9: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view10), this); break;
case 10: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view11), this); break;
case 11: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view12), this); break;
case 12: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view13), this); break;
case 13: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view14), this); break;
case 14: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view15), this); break;
case 15: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view16), this); break;
case 16: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view17), this); break;
case 17: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view18), this); break;
case 18: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view19), this); break;
case 19: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view20), this); break;
case 20: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view21), this); break;
case 21: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view22), this); break;
case 22: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view23), this); break;
case 23: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view24), this); break;
case 24: g_signal_connect( view_select_view, "activate", G_CALLBACK(ala_activate_select_view25), this); break;
}
gtk_menu_shell_append(GTK_MENU_SHELL(view_select_menu), view_select_view);
}
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_select),
GTK_WIDGET(view_select_menu));
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_shift_view);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_select);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_disp_hundredth);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_hide_object);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_hide_text);
GtkWidget *view = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Help entry
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Help"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help),
gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_help, "activate", G_CALLBACK(ala_activate_help), this);
gtk_widget_add_accelerator( help_help, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *help_helpevent = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Help Selected Event"));
g_signal_connect( help_helpevent, "activate",
G_CALLBACK(ala_activate_helpevent), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_helpevent);
GtkWidget *help = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Create ala evlist
ala = new EvListGtk( this, ala_vbox, ev_eType_AlarmList, ala_size, eventname_seg,
&ala_widget, ala_init_cb);
ala->start_trace_cb = &ala_start_trace_cb;
ala->display_in_xnav_cb =&ala_display_in_xnav_cb;
ala->name_to_alias_cb = &ala_name_to_alias_cb;
ala->popup_menu_cb = &ala_popup_menu_cb;
ala->sound_cb = &ala_sound_cb;
ala->help_event_cb = &help_event_cb;
ala->selection_changed_cb = &ala_selection_changed_cb;
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *tools_ack = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_acknowledge.png");
gtk_container_add( GTK_CONTAINER( tools_ack), gtk_image_new_from_file( fname));
g_signal_connect(tools_ack, "clicked", G_CALLBACK(ala_activate_ack_last), this);
g_object_set( tools_ack, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_ack, CoWowGtk::translate_utf8("Acknowledge"), "");
GtkWidget *tools_zoom_in = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_in),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(ala_activate_zoom_in), this);
g_object_set( tools_zoom_in, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_in,CoWowGtk::translate_utf8("Zoom in"), "");
GtkWidget *tools_zoom_out = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_out),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(ala_activate_zoom_out), this);
g_object_set( tools_zoom_out, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_out,CoWowGtk::translate_utf8("Zoom out"), "");
GtkWidget *tools_zoom_reset = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_reset),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(ala_activate_zoom_reset), this);
g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_reset,CoWowGtk::translate_utf8("Zoom reset"), "");
ala_methodtoolbar = new XttMethodToolbarGtk(0, 0, ~0, "");
GtkToolbar *tools_meth = (GtkToolbar *) ((XttMethodToolbarGtk *)ala_methodtoolbar)->build();
ala_methodtoolbar->m_xnav = (XNav *)((Ev *)parent_ctx)->parent_ctx;
ala_methodtoolbar->m_parent_ctx = ala;
ala_methodtoolbar->get_select_cb = ala->get_select;
ala_sup_methodtoolbar = new XttMethodToolbarGtk(0, 0, mt_mMethod_OpenPlc | mt_mMethod_RtNavigator,
" for supervisory object");
GtkToolbar *tools_sup = (GtkToolbar *) ((XttMethodToolbarGtk *)ala_sup_methodtoolbar)->build();
ala_sup_methodtoolbar->m_xnav = (XNav *)((Ev *)parent_ctx)->parent_ctx;
ala_sup_methodtoolbar->m_parent_ctx = ala;
ala_sup_methodtoolbar->get_select_cb = ala->get_select_supobject;
GtkWidget *ala_toolsbox = gtk_hbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(tools), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(gtk_separator_tool_item_new()), FALSE, FALSE, 4);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(tools_sup), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(gtk_separator_tool_item_new()), FALSE, FALSE, 4);
gtk_box_pack_start( GTK_BOX(ala_toolsbox), GTK_WIDGET(tools_meth), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(ala_vbox), GTK_WIDGET(ala_toolsbox), FALSE, FALSE, 0);
gtk_box_pack_end( GTK_BOX(ala_vbox), GTK_WIDGET(ala_widget), TRUE, TRUE, 0);
if ( !(options & ev_mAlaOptions_Embedded)) {
gtk_container_add( GTK_CONTAINER(parent_wid_ala), ala_vbox);
}
// gtk_widget_show_all( parent_wid_ala);
ala_methodtoolbar->set_sensitive();
ala_sup_methodtoolbar->set_sensitive();
// }
if ( !(options & ev_mAlaOptions_Embedded)) {
gtk_widget_show_all( parent_wid_ala);
if ( !(x == 0 && y == 0)) {
// Set position
gtk_window_move( GTK_WINDOW(parent_wid_ala), x, y);
}
}
else
gtk_widget_set_size_request( ala_vbox, ala_width, ala_height);
ala_displayed = 1;
wow = new CoWowGtk( parent_wid_ala);
*status = 1;
}
int main(int argc,char *argv[])
{
char dmmy[20];
GtkWidget *main_window;
GtkWidget *v_box;
GtkWidget *h_box;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *right_side;
GtkWidget *game_border;
GtkWidget *next_block_border;
GdkBitmap *mask;
GtkWidget *menu_bar;
GtkWidget *menu_game;
GtkWidget *menu_game_menu;
GtkWidget *separatormenuitem1;
GtkWidget *separator1;
GtkWidget *menu_settings;
GtkWidget *menu_settings_menu;
GtkWidget *menu_help;
GtkWidget *menu_help_menu;
GtkWidget *help1;
GtkWidget *high_scores1;
GtkWidget *separator2;
GtkWidget *about1;
GtkAccelGroup* accel_group;
//init game values
game_play=FALSE;
get_opt_file(options_f,100);
read_options();
game_over = TRUE;
game_pause = FALSE;
current_x = current_y = 0;
current_block = current_frame = 0;
current_score = current_lines = 0;
current_level = options.level;
next_block = next_frame = 0;
// seed random generator
srandom(time(NULL));
//options.shw_nxt = TRUE;
gtk_set_locale();
gtk_init(&argc,&argv);
accel_group = gtk_accel_group_new();
// window
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_policy(GTK_WINDOW(main_window),FALSE,FALSE,TRUE);
gtk_window_set_title(GTK_WINDOW(main_window),"GTK Tetris");
g_signal_connect ((gpointer) main_window, "key_press_event",
G_CALLBACK (keyboard_event_handler),
NULL);
// vertical box
v_box = gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(main_window),v_box);
gtk_widget_show(v_box);
// menu stuff
menu_bar = gtk_menu_bar_new();
gtk_widget_show(menu_bar);
gtk_box_pack_start(GTK_BOX(v_box),menu_bar,FALSE,FALSE,0);
//Game sub-menu
menu_game=gtk_menu_item_new_with_mnemonic ("_Game");
gtk_widget_show(menu_game);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_game);
menu_game_menu=gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_game), menu_game_menu);
menu_game_quick = gtk_menu_item_new_with_mnemonic ("Start Game");
gtk_widget_show (menu_game_quick);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quick);
g_signal_connect ((gpointer) menu_game_quick, "activate",
G_CALLBACK (game_start_stop),
NULL);
gtk_widget_add_accelerator (menu_game_quick, "activate", accel_group,
GDK_G, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
menu_game_stop = gtk_menu_item_new_with_mnemonic ("Stop Game");
gtk_widget_show (menu_game_stop);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_stop);
g_signal_connect ((gpointer) menu_game_stop, "activate",
G_CALLBACK (game_start_stop),
NULL);
gtk_widget_add_accelerator (menu_game_stop, "activate", accel_group,
GDK_O, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_set_sensitive(menu_game_stop,FALSE);
menu_game_pause = gtk_check_menu_item_new_with_mnemonic ("Pause");
gtk_widget_show (menu_game_pause);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_pause);
g_signal_connect ((gpointer) menu_game_pause, "activate",
G_CALLBACK (game_set_pause),
NULL);
gtk_widget_add_accelerator (menu_game_pause, "activate", accel_group,
GDK_P, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
separatormenuitem1 = gtk_menu_item_new ();
gtk_widget_show (separatormenuitem1);
gtk_container_add (GTK_CONTAINER (menu_game_menu), separatormenuitem1);
gtk_widget_set_sensitive (separatormenuitem1, FALSE);
menu_game_quit = gtk_menu_item_new_with_mnemonic ("Quit");
gtk_widget_show (menu_game_quit);
gtk_container_add (GTK_CONTAINER (menu_game_menu), menu_game_quit);
g_signal_connect ((gpointer) menu_game_quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_widget_add_accelerator(menu_game_quit,"activate", accel_group,
GDK_X, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
//Settings sub-menu
menu_settings = gtk_menu_item_new_with_mnemonic ("_Settings");
gtk_widget_show (menu_settings);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_settings);
menu_settings_menu=gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_settings),
menu_settings_menu);
menu_game_start = gtk_menu_item_new_with_mnemonic ("Level Settings");
gtk_widget_show (menu_game_start);
gtk_container_add (GTK_CONTAINER (menu_settings_menu), menu_game_start);
g_signal_connect ((gpointer) menu_game_start, "activate",
G_CALLBACK (show_new_game),
NULL);
menu_game_show_next_block = gtk_check_menu_item_new_with_mnemonic ("Show next block");
gtk_widget_show (menu_game_show_next_block);
gtk_container_add (GTK_CONTAINER (menu_settings_menu),
menu_game_show_next_block);
if (options.shw_nxt)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_game_show_next_block),
TRUE);
g_signal_connect ((gpointer) menu_game_show_next_block, "activate",
G_CALLBACK (game_show_next_block),
NULL);
gtk_widget_add_accelerator (menu_game_show_next_block, "activate",
accel_group,
GDK_N, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
separator1 = gtk_menu_item_new ();
gtk_widget_show (separator1);
gtk_container_add (GTK_CONTAINER (menu_settings_menu), separator1);
gtk_widget_set_sensitive (separator1, FALSE);
menu_save_options = gtk_menu_item_new_with_mnemonic ("Save Settings");
gtk_widget_show (menu_save_options);
gtk_container_add (GTK_CONTAINER (menu_settings_menu),
menu_save_options);
g_signal_connect ((gpointer) menu_save_options, "activate",
G_CALLBACK (save_options),
NULL);
//Help sub-menu
menu_help=gtk_menu_item_new_with_mnemonic ("_Help");
gtk_widget_show (menu_help);
gtk_container_add (GTK_CONTAINER (menu_bar), menu_help);
gtk_menu_item_set_right_justified (GTK_MENU_ITEM(menu_help),TRUE);
menu_help_menu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_help),
menu_help_menu);
help1 = gtk_menu_item_new_with_mnemonic ("Help");
gtk_widget_show (help1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), help1);
g_signal_connect ((gpointer) help1, "activate",
G_CALLBACK (show_help),
NULL);
gtk_widget_add_accelerator (help1, "activate",
accel_group,
GDK_F1, (GdkModifierType) 0,
GTK_ACCEL_VISIBLE);
high_scores1 = gtk_menu_item_new_with_mnemonic ("High-scores");
gtk_widget_show (high_scores1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), high_scores1);
g_signal_connect ((gpointer) high_scores1, "activate",
G_CALLBACK (show_highscore_wrapper),
NULL);
separator2 = gtk_menu_item_new ();
gtk_widget_show (separator2);
gtk_container_add (GTK_CONTAINER (menu_help_menu), separator2);
gtk_widget_set_sensitive (separator2, FALSE);
about1 = gtk_menu_item_new_with_mnemonic ("About");
gtk_widget_show (about1);
gtk_container_add (GTK_CONTAINER (menu_help_menu), about1);
g_signal_connect ((gpointer) about1, "activate",
G_CALLBACK (show_about),
NULL);
// horizontal box
h_box = gtk_hbox_new(FALSE,1);
gtk_widget_show(h_box);
gtk_box_pack_start(GTK_BOX(v_box),h_box,FALSE,FALSE,0);
// game_border
game_border = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(game_border),GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(h_box),game_border,FALSE,FALSE,1);
gtk_widget_show(game_border);
// game_area
game_area = gtk_drawing_area_new();
gtk_widget_show(game_area);
gtk_drawing_area_size(GTK_DRAWING_AREA(game_area),
MAX_X*BLOCK_WIDTH,MAX_Y*BLOCK_HEIGHT);
g_signal_connect ((gpointer) game_area, "expose_event",
G_CALLBACK (game_area_expose_event),
NULL);
gtk_widget_set_events(game_area, GDK_EXPOSURE_MASK);
gtk_container_add(GTK_CONTAINER(game_border),game_area);
// right_side
right_side = gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(h_box),right_side,FALSE,FALSE,0);
gtk_widget_show(right_side);
// next_block_border
next_block_border = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(next_block_border),GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(right_side),next_block_border,FALSE,FALSE,0);
gtk_widget_show(next_block_border);
// next_block_area
next_block_area = gtk_drawing_area_new();
gtk_widget_show(next_block_area);
gtk_drawing_area_size(GTK_DRAWING_AREA(next_block_area),
4*BLOCK_WIDTH,4*BLOCK_HEIGHT);
g_signal_connect ((gpointer) next_block_area, "expose_event",
G_CALLBACK (next_block_area_expose_event),
NULL);
gtk_widget_set_events(next_block_area, GDK_EXPOSURE_MASK);
gtk_container_add(GTK_CONTAINER(next_block_border),next_block_area);
// the score,level and lines labels
score_label1 = gtk_label_new("Score:");
gtk_label_set_justify(GTK_LABEL(score_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(score_label1);
gtk_box_pack_start(GTK_BOX(right_side),score_label1,FALSE,FALSE,3);
score_label2 = gtk_label_new("0");
set_gtk_color_style(score_label2,0xffff,0,0);
gtk_label_set_justify(GTK_LABEL(score_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(score_label2);
gtk_box_pack_start(GTK_BOX(right_side),score_label2,FALSE,FALSE,3);
level_label1 = gtk_label_new("Level:");
gtk_label_set_justify(GTK_LABEL(level_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(level_label1);
gtk_box_pack_start(GTK_BOX(right_side),level_label1,FALSE,FALSE,3);
sprintf(dmmy,"%d",current_level);
level_label2 = gtk_label_new(dmmy);
set_gtk_color_style(level_label2,0,0,0xffff);
gtk_label_set_justify(GTK_LABEL(level_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(level_label2);
gtk_box_pack_start(GTK_BOX(right_side),level_label2,FALSE,FALSE,3);
lines_label1 = gtk_label_new("Lines:");
gtk_label_set_justify(GTK_LABEL(lines_label1),GTK_JUSTIFY_RIGHT);
gtk_widget_show(lines_label1);
gtk_box_pack_start(GTK_BOX(right_side),lines_label1,FALSE,FALSE,3);
lines_label2 = gtk_label_new("0");
gtk_label_set_justify(GTK_LABEL(lines_label2),GTK_JUSTIFY_RIGHT);
gtk_widget_show(lines_label2);
gtk_box_pack_start(GTK_BOX(right_side),lines_label2,FALSE,FALSE,3);
//the game buttons
//Start_stop
Start_stop_button = gtk_button_new();
gtk_widget_show(Start_stop_button);
g_signal_connect ((gpointer) Start_stop_button, "clicked",
G_CALLBACK (game_start_stop),
NULL);
Start_stop_button_label= gtk_label_new(start_stop_str[0]);
box2 = label_box(right_side, Start_stop_button_label,
start_stop_str[0] );
gtk_widget_show(box2);
gtk_container_add (GTK_CONTAINER (Start_stop_button), box2);
gtk_box_pack_start(GTK_BOX(right_side),Start_stop_button,FALSE,FALSE,3);
GTK_WIDGET_SET_FLAGS(Start_stop_button, GTK_CAN_DEFAULT);
gtk_widget_grab_default(Start_stop_button);
//Pause
Pause_button = gtk_button_new();
gtk_widget_show(Pause_button);
g_signal_connect ((gpointer) Pause_button, "clicked",
G_CALLBACK (game_set_pause_b),
NULL);
Pause_button_label = gtk_label_new(pause_str[0]);
box1 = label_box(right_side, Pause_button_label, pause_str[0] );
gtk_widget_show(box1);
gtk_container_add (GTK_CONTAINER (Pause_button), box1);
gtk_box_pack_start(GTK_BOX(right_side),Pause_button,FALSE,FALSE,3);
GTK_WIDGET_SET_FLAGS(Pause_button, GTK_CAN_DEFAULT);
gtk_widget_set_sensitive(Pause_button,FALSE);
gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group);
gtk_widget_show(main_window);
// Block images...
blocks_pixmap = gdk_pixmap_create_from_xpm_d(game_area->window,
&mask,
NULL,
(gchar **)blocks_xpm);
gtk_main ();
return 0;
}
GtkWidget * menu_new()
{
Menu * menubar = g_object_new(VEX_TYPE_MENU, NULL);
/********************************************************************************************
* the following part is autogenerated; to regenerate, type:
* :r !./misc/menu_gen.py 2 misc/Menu.txt
********************************************************************************************/
GtkWidget *item_1 = gtk_menu_item_new_with_mnemonic("_File");
GtkWidget *menu_1 = gtk_menu_new();
GtkWidget *item_1_1 = gtk_menu_item_new_with_mnemonic("Open new _Window");
GtkWidget *item_1_2 = gtk_menu_item_new_with_mnemonic("Open new _Tab");
GtkWidget *item_1_3 = gtk_menu_item_new_with_mnemonic("_Quit");
GtkWidget *item_2 = gtk_menu_item_new_with_mnemonic("_View");
GtkWidget *menu_2 = gtk_menu_new();
GtkWidget *item_2_1 = gtk_check_menu_item_new_with_mnemonic("_Fullscreen");
GtkWidget *item_2_2 = gtk_menu_item_new_with_mnemonic("_Tabs Position");
GtkWidget *item_3 = gtk_menu_item_new_with_mnemonic("_Options");
GtkWidget *menu_3 = gtk_menu_new();
GtkWidget *item_3_1 = gtk_menu_item_new_with_mnemonic("_Preferences");
GtkWidget *item_4 = gtk_menu_item_new_with_mnemonic("_Profile");
GtkWidget *item_5 = gtk_menu_item_new_with_mnemonic("_Debug");
GtkWidget *menu_5 = gtk_menu_new();
GtkWidget *item_5_1 = gtk_check_menu_item_new_with_mnemonic("Show Scrolling _Region");
GtkWidget *item_5_2 = gtk_check_menu_item_new_with_mnemonic("Show _Status Bar");
GtkWidget *item_6 = gtk_menu_item_new_with_mnemonic("_Help");
GtkWidget *menu_6 = gtk_menu_new();
GtkWidget *item_6_1 = gtk_menu_item_new_with_mnemonic("_Manual");
GtkWidget *item_6_2 = gtk_menu_item_new_with_mnemonic("_About vexterm");
GtkWidget *item_6_3 = gtk_menu_item_new_with_mnemonic("_License");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_1), menu_1);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_2), menu_2);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_3), menu_3);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_5), menu_5);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item_6), menu_6);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_1);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_1), item_1_1);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_1), item_1_2);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_1), item_1_3);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_2);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_2), item_2_1);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_2), item_2_2);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_3);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_3), item_3_1);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_4);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_5);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_1);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_5), item_5_2);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item_6);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_6), item_6_1);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_6), item_6_2);
gtk_menu_shell_append(GTK_MENU_SHELL(menu_6), item_6_3);
menubar -> menu_file_new_window = item_1_1;
menubar -> menu_file_new_tab = item_1_2;
menubar -> menu_file_quit = item_1_3;
menubar -> menu_view_fullscreen = item_2_1;
menubar -> menu_view_tabs_position = item_2_2;
menubar -> menu_options_preferences = item_3_1;
menubar -> menu_profiles = item_4;
menubar -> menu_show_scrolling_region = item_5_1;
menubar -> menu_show_status_bar = item_5_2;
menubar -> menu_help_manual = item_6_1;
menubar -> menu_help_about_vexterm = item_6_2;
menubar -> menu_help_license = item_6_3;
// END
/********************************************************************************************
* end auto-generated part
********************************************************************************************/
menubar -> main_window = NULL;
g_signal_connect( // this will assign 'menubar -> main_window' on map-signal
G_OBJECT(menubar), "map",
G_CALLBACK(menu_map_cb), NULL);
/********************************************************************************************
* signals
********************************************************************************************/
g_signal_connect(
G_OBJECT(menubar -> menu_file_quit), "activate",
G_CALLBACK(exit_cb), (gpointer)menubar);
g_signal_connect(
G_OBJECT(menubar -> menu_view_fullscreen), "toggled",
G_CALLBACK(menubar_fullscreen_cb), (gpointer)menubar);
return GTK_WIDGET(menubar);
}
WPkgGtk::WPkgGtk(
GtkWidget *wa_parent_wid,
void *wa_parent_ctx)
: WPkg(wa_parent_ctx), parent_wid(wa_parent_wid),
clock_cursor(0)
{
const int window_width = 600;
const int window_height = 600;
int sts;
pwr_tFileName fname;
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", "Distributor",
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);
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_history = gtk_menu_item_new_with_mnemonic( "_History");
g_signal_connect( file_history, "activate",
G_CALLBACK(WPkgGtk::activate_history), this);
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(WPkgGtk::activate_exit), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_history);
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));
// Functions Entry
GtkWidget *functions_distribute = gtk_menu_item_new_with_mnemonic( "_Distribute");
g_signal_connect( functions_distribute, "activate",
G_CALLBACK(WPkgGtk::activate_distribute), this);
gtk_widget_add_accelerator( functions_distribute, "activate", accel_g,
'd', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_createpkg = gtk_menu_item_new_with_mnemonic( "_Create Package");
g_signal_connect( functions_createpkg, "activate",
G_CALLBACK(WPkgGtk::activate_createpkg), this);
GtkWidget *functions_deletepkg = gtk_menu_item_new_with_mnemonic( "D_elete Package");
g_signal_connect( functions_deletepkg, "activate",
G_CALLBACK(WPkgGtk::activate_deletepkg), this);
GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_distribute);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_createpkg);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_deletepkg);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic("F_unctions");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu));
// View menu
GtkWidget *view_zoom_in = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect(view_zoom_in, "activate", G_CALLBACK(WPkgGtk::activate_zoom_in), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect(view_zoom_out, "activate", G_CALLBACK(WPkgGtk::activate_zoom_out), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL);
g_signal_connect(view_zoom_reset, "activate", G_CALLBACK(WPkgGtk::activate_zoom_reset), this);
GtkWidget *view_dmode_filediff = gtk_check_menu_item_new_with_mnemonic( "_Display File Differences");
g_signal_connect( view_dmode_filediff, "activate",
G_CALLBACK(WPkgGtk::activate_dmode_filediff), this);
GtkWidget *view_dmode_filetime = gtk_check_menu_item_new_with_mnemonic( "Display Files In _Time Order");
g_signal_connect( view_dmode_filetime, "activate",
G_CALLBACK(WPkgGtk::activate_dmode_filetime), this);
GtkWidget *view_dmode_filepath = gtk_check_menu_item_new_with_mnemonic( "Display File _Path");
g_signal_connect( view_dmode_filepath, "activate",
G_CALLBACK(WPkgGtk::activate_dmode_filepath), this);
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_dmode_filediff);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_dmode_filetime);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_dmode_filepath);
GtkWidget *view = gtk_menu_item_new_with_mnemonic("_View");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Menu Help
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic("_Help");
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help),
gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_help, "activate", G_CALLBACK(WPkgGtk::activate_help), this);
gtk_widget_add_accelerator( help_help, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
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));
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *tools_distribute = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/wpkg_distribute.png");
gtk_container_add( GTK_CONTAINER(tools_distribute),
gtk_image_new_from_file( fname));
g_signal_connect(tools_distribute, "clicked", G_CALLBACK(WPkgGtk::activate_distribute), this);
g_object_set( tools_distribute, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_distribute, "Distribute", "");
GtkWidget *tools_zoom_in = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_in),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(WPkgGtk::activate_zoom_in), this);
g_object_set( tools_zoom_in, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_in, "Zoom in", "");
GtkWidget *tools_zoom_out = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_out),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(WPkgGtk::activate_zoom_out), this);
g_object_set( tools_zoom_out, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_out, "Zoom out", "");
GtkWidget *tools_zoom_reset = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_reset),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(WPkgGtk::activate_zoom_reset), this);
g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_reset, "Zoom reset", "");
GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
utility = ((WUtility *)parent_ctx)->utype;
wpkgnav = new WPkgNavGtk( (void *)this, vbox, "Packages",
utility, &brow_widget, &sts);
((WPkgNav *)wpkgnav)->message_cb = message_cb;
((WPkgNav *)wpkgnav)->set_clock_cursor_cb = set_clock_cursor_cb;
((WPkgNav *)wpkgnav)->reset_cursor_cb = reset_cursor_cb;
GtkWidget *statusbar = gtk_hbox_new( FALSE, 0);
msg_label = gtk_label_new( "");
gtk_box_pack_start( GTK_BOX(statusbar), msg_label, FALSE, FALSE, 20);
gtk_widget_show_all( statusbar);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(tools), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(brow_widget), TRUE, TRUE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(statusbar), FALSE, FALSE, 3);
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all( toplevel);
wow = new CoWowGtk( toplevel);
if ( utility == wb_eUtility_Wtt) {
((Wtt *)parent_ctx)->register_utility( (void *) this,
wb_eUtility_Distributor);
}
}
