static void
save_merged(GtkWidget *widget,
gpointer data)
{
save_script();
gtk_notebook_next_page(GTK_NOTEBOOK(notebook));
while(gtk_events_pending())
gtk_main_iteration();
sleep(5);
gtk_notebook_prev_page(GTK_NOTEBOOK(notebook));
gtk_notebook_prev_page(GTK_NOTEBOOK(notebook));
gtk_notebook_prev_page(GTK_NOTEBOOK(notebook));
gtk_notebook_prev_page(GTK_NOTEBOOK(notebook));
}
void
eom_properties_dialog_set_netbook_mode (EomPropertiesDialog *dlg,
gboolean enable)
{
EomPropertiesDialogPrivate *priv;
g_return_if_fail (EOM_IS_PROPERTIES_DIALOG (dlg));
priv = dlg->priv;
if (priv->netbook_mode == enable)
return;
priv->netbook_mode = enable;
#ifdef HAVE_METADATA
if (enable) {
gtk_widget_reparent (priv->metadata_details_sw,
priv->metadata_details_box);
// Only show details box if metadata is being displayed
if (gtk_widget_get_visible (priv->exif_box))
gtk_widget_show_all (priv->metadata_details_box);
gtk_widget_hide_all (priv->exif_details_expander);
} else {
gtk_widget_reparent (priv->metadata_details_sw,
priv->exif_details_expander);
gtk_widget_show_all (priv->exif_details_expander);
if (gtk_notebook_get_current_page (GTK_NOTEBOOK (priv->notebook)) == EOM_PROPERTIES_DIALOG_PAGE_DETAILS)
gtk_notebook_prev_page (GTK_NOTEBOOK (priv->notebook));
gtk_widget_hide_all (priv->metadata_details_box);
}
#endif
}
void linphone_gtk_remove_in_call_view(LinphoneCall *call) {
GtkWidget *w=(GtkWidget*)linphone_call_get_user_pointer (call);
GtkWidget *main_window=linphone_gtk_get_main_window ();
GtkWidget *nb=linphone_gtk_get_widget(main_window,"viewswitch");
gboolean in_conf=linphone_call_params_get_local_conference_mode(linphone_call_get_current_params(call));
int idx;
g_return_if_fail(w!=NULL);
idx=gtk_notebook_page_num(GTK_NOTEBOOK(nb),w);
if (in_conf) {
linphone_gtk_unset_from_conference(call);
}
linphone_call_set_user_pointer (call,NULL);
linphone_call_unref(call);
call=linphone_core_get_current_call(linphone_gtk_get_core());
if (call==NULL) {
if (linphone_core_is_in_conference(linphone_gtk_get_core())) {
/*show the conference*/
gtk_notebook_set_current_page(GTK_NOTEBOOK(nb),gtk_notebook_page_num(GTK_NOTEBOOK(nb),
g_object_get_data(G_OBJECT(main_window),"conf_frame")));
} else gtk_notebook_prev_page(GTK_NOTEBOOK(nb));
} else {
/*show the active call*/
gtk_notebook_set_current_page(GTK_NOTEBOOK(nb),gtk_notebook_page_num(GTK_NOTEBOOK(nb), linphone_call_get_user_pointer(call)));
}
gtk_notebook_remove_page (GTK_NOTEBOOK(nb),idx);
gtk_widget_destroy(w);
}
gint main_window_key_press_event(GtkWidget *widget, GdkEventKey *event,gpointer user_data)
{
if (main_window.notebook_editor != NULL) {
check_externally_modified(document_manager_get_current_document(main_window.docmg));
if (((event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK))==(GDK_CONTROL_MASK | GDK_SHIFT_MASK)) && (event->keyval == GDK_ISO_Left_Tab)) {
// Hack, for some reason when shift is held down keyval comes through as GDK_ISO_Left_Tab not GDK_Tab
if (gtk_notebook_get_current_page(GTK_NOTEBOOK(main_window.notebook_editor)) == 0) {
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_window.notebook_editor), gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_window.notebook_editor))-1);
}
else {
gtk_notebook_prev_page(GTK_NOTEBOOK(main_window.notebook_editor));
}
return TRUE;
}
else if ((event->state & GDK_CONTROL_MASK)==GDK_CONTROL_MASK && (event->keyval == GDK_Tab)) {
if (gtk_notebook_get_current_page(GTK_NOTEBOOK(main_window.notebook_editor)) == gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_window.notebook_editor))-1) {
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_window.notebook_editor),0);
}
else {
gtk_notebook_next_page(GTK_NOTEBOOK(main_window.notebook_editor));
}
return TRUE;
}
else if ((event->state & GDK_MOD1_MASK)==GDK_MOD1_MASK && ((event->keyval >= GDK_0) && (event->keyval <= GDK_9))) {
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_window.notebook_editor),event->keyval - ((event->keyval == GDK_0) ? (GDK_0 - 9) : (GDK_0 + 1)));
return TRUE;
}
}
return FALSE;
}
static void
fdriverchooser_prev_clicked (GtkWidget * widget, TFDRIVERCHOOSER * choose_t)
{
if (choose_t)
{
gtk_notebook_prev_page (GTK_NOTEBOOK (choose_t->tab_panel));
}
}
static void mainwindow_prev_tab(GtkWidget *widget, gpointer user_data) {
if(gtk_notebook_get_current_page(tabbar) == (0))
gtk_notebook_set_current_page(tabbar, (tabcount - 1));
else
gtk_notebook_prev_page(tabbar);
activetab = gtk_notebook_get_current_page(tabbar);
mainwindow_focus_terminal();
}
/* Move to the previous tab in the GtkNotebook. */
static void
previous_tab (GtkButton *button,
GtkNotebook *notebook)
{
if (gtk_notebook_get_current_page (notebook) == 0)
gtk_notebook_set_current_page (notebook, 3);
else
gtk_notebook_prev_page (notebook);
}
/* Switches to the previous page.
* Nothing happens if the current page is the first page. */
int
clip_GTK_NOTEBOOKPREVPAGE(ClipMachine * cm)
{
C_widget *cntb = _fetch_cw_arg(cm);
CHECKCWID(cntb,GTK_IS_NOTEBOOK);
gtk_notebook_prev_page(GTK_NOTEBOOK(cntb->widget));
return 0;
err:
return 1;
}
/* Response signal handler. This function is needed because GtkDialog's
* handler for this signal closes the dialog and we don't want that, we
* want to change pages and, dimm certain response buttons. Overriding the
* virtual function would not work because that would be called after the
* signal handler implemented by GtkDialog.
* FIXME: There is a much saner way to do that [MDK] */
static void
response (HildonWizardDialog *wizard_dialog,
gint response_id,
gpointer unused)
{
HildonWizardDialogPrivate *priv = HILDON_WIZARD_DIALOG_GET_PRIVATE (wizard_dialog);
GtkNotebook *notebook = priv->notebook;
gint current = 0;
gint last = gtk_notebook_get_n_pages (notebook) - 1;
gboolean is_first, is_last;
g_assert (priv);
current = gtk_notebook_current_page (notebook);
switch (response_id) {
case HILDON_WIZARD_DIALOG_PREVIOUS:
--current;
is_last = (current == last);
is_first = (current == 0);
make_buttons_sensitive (wizard_dialog,
!is_first, !is_first, !is_last);
gtk_notebook_prev_page (notebook); /* go to previous page */
break;
case HILDON_WIZARD_DIALOG_NEXT:
if (!priv->forward_function ||
(*priv->forward_function) (priv->notebook, current, priv->forward_function_data)) {
++current;
is_last = (current == last);
is_first = (current == 0);
make_buttons_sensitive (wizard_dialog,
!is_first, !is_first, !is_last);
gtk_notebook_next_page (notebook); /* go to next page */
}
break;
case HILDON_WIZARD_DIALOG_FINISH:
return;
}
current = gtk_notebook_get_current_page (notebook);
is_last = current == last;
is_first = current == 0;
/* Don't let the dialog close */
g_signal_stop_emission_by_name (wizard_dialog, "response");
/* New page number may appear in the title, update it */
if (priv->autotitle)
create_title (wizard_dialog);
}
void
_xedit_cmd_documents_previous_document (GtkAction *action,
XeditWindow *window)
{
GtkNotebook *notebook;
xedit_debug (DEBUG_COMMANDS);
notebook = GTK_NOTEBOOK (_xedit_window_get_notebook (window));
gtk_notebook_prev_page (notebook);
}
void
_pluma_cmd_documents_previous_document (GtkAction *action,
PlumaWindow *window)
{
GtkNotebook *notebook;
pluma_debug (DEBUG_COMMANDS);
notebook = GTK_NOTEBOOK (_pluma_window_get_notebook (window));
gtk_notebook_prev_page (notebook);
}
void gui_show_quote_page(gboolean show)
{
/* Normal keyboard focus when visible */
chat_set_grab_focus_on_update(!show);
if (show) {
gtk_widget_show(quote_page);
gtk_notebook_set_current_page(GTK_NOTEBOOK(map_notebook),
QUOTE_PAGE);
} else {
gtk_notebook_prev_page(GTK_NOTEBOOK(map_notebook));
gtk_widget_hide(quote_page);
}
}
void
_gedit_cmd_documents_previous_document (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GeditWindow *window = GEDIT_WINDOW (user_data);
GtkNotebook *notebook;
gedit_debug (DEBUG_COMMANDS);
notebook = GTK_NOTEBOOK (_gedit_window_get_notebook (window));
gtk_notebook_prev_page (notebook);
}
void tabwin_navigate (windata_t *vwin, guint key)
{
tabwin_t *tabwin = vwin_get_tabwin(vwin);
GtkNotebook *notebook = GTK_NOTEBOOK(tabwin->tabs);
if (key == GDK_less || key == GDK_Page_Up) {
gtk_notebook_prev_page(notebook);
} else if (key == GDK_greater || key == GDK_Page_Down) {
gtk_notebook_next_page(notebook);
} else {
/* numeric value, 1 to 9 */
gtk_notebook_set_current_page(notebook, key - 1);
}
}
static gboolean
term_died (TemuTerminal *term, gpointer user_data)
{
tracker_t *tracker = (tracker_t *) user_data;
terms_t *terms = tracker->terms;
int status;
waitpid (-1, &status, WNOHANG);
gtk_notebook_prev_page (terms->notebook);
gtk_widget_hide (GTK_WIDGET(term));
gtk_container_remove (GTK_CONTAINER(terms->notebook), GTK_WIDGET(term));
terms->active[tracker->n] = NULL;
gtk_widget_destroy (GTK_WIDGET(term));
return TRUE;
}
/**
* ephy_notebook_prev_page:
* @notebook: an #EphyNotebook
*
* Advances to the previous page in the @notebook. Note that unlike
* gtk_notebook_next_page() this method will wrap around if
* #GtkSettings:gtk-keynav-wrap-around is set.
**/
void
ephy_notebook_prev_page (EphyNotebook *notebook)
{
gint current_page;
g_assert (EPHY_IS_NOTEBOOK (notebook));
current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
if (current_page > 0)
gtk_notebook_prev_page (GTK_NOTEBOOK (notebook));
else {
gboolean wrap_around;
g_object_get (gtk_widget_get_settings (GTK_WIDGET (notebook)),
"gtk-keynav-wrap-around", &wrap_around,
NULL);
if (wrap_around)
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), -1);
}
}
void
nautilus_notebook_prev_page (NautilusNotebook *notebook)
{
gint current_page;
g_return_if_fail (NAUTILUS_IS_NOTEBOOK (notebook));
current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook));
if (current_page > 0)
gtk_notebook_prev_page (GTK_NOTEBOOK (notebook));
else {
gboolean wrap_around;
g_object_get (gtk_widget_get_settings (GTK_WIDGET (notebook)),
"gtk-keynav-wrap-around", &wrap_around,
NULL);
if (wrap_around)
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), -1);
}
}
GLADE_CB gboolean
on_dbgmem_key_press_event (GtkWidget *widget,
GdkEventKey *event,
gpointer user_data)
{
GtkNotebook *nb = GTK_NOTEBOOK(notebook);
switch(event->keyval)
{
case GDK_F1:
dbgmem_button1_clicked(NULL, NULL);
return TRUE;
case GDK_F2:
dbgmem_button2_clicked(NULL, NULL);
return TRUE;
case GDK_F3:
dbgmem_button3_clicked(NULL, NULL);
return TRUE;
case GDK_F4:
dbgmem_button4_clicked(NULL, NULL);
return TRUE;
case GDK_F5:
dbgmem_button5_clicked(NULL, NULL);
return TRUE;
case GDK_F6:
dbgmem_button6_clicked(NULL, NULL);
return TRUE;
case GDK_F7:
gtk_notebook_next_page(nb);
return TRUE;
case GDK_F8:
gtk_notebook_prev_page(nb);
return TRUE;
default:
return FALSE;
}
return FALSE;
}
void wxMDIParentFrame::ActivatePrevious()
{
if (m_clientWindow)
gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
}
void
ui_tab_prev(void)
{
gtk_notebook_prev_page(GTK_NOTEBOOK(nbook));
}
/* Tab scrolling was removed from GtkNotebook in gtk 3, so reimplement it here */
static gboolean
scroll_event_cb (GtkWidget *widget,
GdkEventScroll *event,
gpointer user_data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
GtkWidget *child, *event_widget, *action_widget;
if ((event->state & gtk_accelerator_get_default_mod_mask ()) != 0)
return FALSE;
child = gtk_notebook_get_nth_page (notebook, gtk_notebook_get_current_page (notebook));
if (child == NULL)
return FALSE;
event_widget = gtk_get_event_widget ((GdkEvent *) event);
/* Ignore scroll events from the content of the page */
if (event_widget == NULL ||
event_widget == child ||
gtk_widget_is_ancestor (event_widget, child))
return FALSE;
/* And also from the action widgets */
action_widget = gtk_notebook_get_action_widget (notebook, GTK_PACK_START);
if (event_widget == action_widget ||
(action_widget != NULL && gtk_widget_is_ancestor (event_widget, action_widget)))
return FALSE;
action_widget = gtk_notebook_get_action_widget (notebook, GTK_PACK_END);
if (event_widget == action_widget ||
(action_widget != NULL && gtk_widget_is_ancestor (event_widget, action_widget)))
return FALSE;
switch (event->direction) {
case GDK_SCROLL_RIGHT:
case GDK_SCROLL_DOWN:
gtk_notebook_next_page (notebook);
return TRUE;
case GDK_SCROLL_LEFT:
case GDK_SCROLL_UP:
gtk_notebook_prev_page (notebook);
return TRUE;
case GDK_SCROLL_SMOOTH:
switch (gtk_notebook_get_tab_pos (notebook)) {
case GTK_POS_LEFT:
case GTK_POS_RIGHT:
if (event->delta_y > 0)
gtk_notebook_next_page (notebook);
else if (event->delta_y < 0)
gtk_notebook_prev_page (notebook);
break;
case GTK_POS_TOP:
case GTK_POS_BOTTOM:
if (event->delta_x > 0)
gtk_notebook_next_page (notebook);
else if (event->delta_x < 0)
gtk_notebook_prev_page (notebook);
break;
}
return TRUE;
}
return FALSE;
}
/* change view and focus to previous notebook page */
void gtkui_page_left(void) {
gtk_notebook_prev_page(GTK_NOTEBOOK (notebook));
}
static void
pd_update_metadata_tab (EomPropertiesDialog *prop_dlg,
EomImage *image)
{
EomPropertiesDialogPrivate *priv;
GtkNotebook *notebook;
#if HAVE_EXIF
ExifData *exif_data;
#endif
#if HAVE_EXEMPI
XmpPtr xmp_data;
#endif
g_return_if_fail (EOM_IS_PROPERTIES_DIALOG (prop_dlg));
priv = prop_dlg->priv;
notebook = GTK_NOTEBOOK (priv->notebook);
if (TRUE
#if HAVE_EXIF
&& !eom_image_has_data (image, EOM_IMAGE_DATA_EXIF)
#endif
#if HAVE_EXEMPI
&& !eom_image_has_data (image, EOM_IMAGE_DATA_XMP)
#endif
) {
if (gtk_notebook_get_current_page (notebook) == EOM_PROPERTIES_DIALOG_PAGE_EXIF) {
gtk_notebook_prev_page (notebook);
} else if (gtk_notebook_get_current_page (notebook) == EOM_PROPERTIES_DIALOG_PAGE_DETAILS) {
gtk_notebook_set_current_page (notebook, EOM_PROPERTIES_DIALOG_PAGE_GENERAL);
}
if (gtk_widget_get_visible (priv->exif_box)) {
gtk_widget_hide_all (priv->exif_box);
}
if (gtk_widget_get_visible (priv->metadata_details_box)) {
gtk_widget_hide_all (priv->metadata_details_box);
}
return;
} else {
if (!gtk_widget_get_visible (priv->exif_box))
gtk_widget_show_all (priv->exif_box);
if (priv->netbook_mode &&
!gtk_widget_get_visible (priv->metadata_details_box)) {
gtk_widget_show_all (priv->metadata_details_box);
gtk_widget_hide_all (priv->exif_details_expander);
}
}
#if HAVE_EXIF
exif_data = (ExifData *) eom_image_get_exif_info (image);
eom_exif_set_label (priv->exif_aperture_label,
exif_data, EXIF_TAG_FNUMBER);
eom_exif_set_label (priv->exif_exposure_label,
exif_data, EXIF_TAG_EXPOSURE_TIME);
eom_exif_set_focal_length_label (priv->exif_focal_label, exif_data);
eom_exif_set_label (priv->exif_flash_label,
exif_data, EXIF_TAG_FLASH);
eom_exif_set_label (priv->exif_iso_label,
exif_data, EXIF_TAG_ISO_SPEED_RATINGS);
eom_exif_set_label (priv->exif_metering_label,
exif_data, EXIF_TAG_METERING_MODE);
eom_exif_set_label (priv->exif_model_label,
exif_data, EXIF_TAG_MODEL);
eom_exif_set_label (priv->exif_date_label,
exif_data, EXIF_TAG_DATE_TIME_ORIGINAL);
eom_exif_details_update (EOM_EXIF_DETAILS (priv->exif_details),
exif_data);
/* exif_data_unref can handle NULL-values */
exif_data_unref(exif_data);
#endif
#if HAVE_EXEMPI
xmp_data = (XmpPtr) eom_image_get_xmp_info (image);
if (xmp_data != NULL) {
eom_xmp_set_label (xmp_data,
NS_IPTC4XMP,
"Location",
priv->xmp_location_label);
eom_xmp_set_label (xmp_data,
NS_DC,
"description",
priv->xmp_description_label);
eom_xmp_set_label (xmp_data,
NS_DC,
"subject",
priv->xmp_keywords_label);
eom_xmp_set_label (xmp_data,
NS_DC,
"creator",
priv->xmp_creator_label);
eom_xmp_set_label (xmp_data,
NS_DC,
"rights",
priv->xmp_rights_label);
eom_exif_details_xmp_update (EOM_EXIF_DETAILS (priv->exif_details), xmp_data);
xmp_free (xmp_data);
} else {
/* Image has no XMP data */
/* Clear the labels so they won't display foreign data.*/
gtk_label_set_text (GTK_LABEL (priv->xmp_location_label), NULL);
gtk_label_set_text (GTK_LABEL (priv->xmp_description_label),
NULL);
gtk_label_set_text (GTK_LABEL (priv->xmp_keywords_label), NULL);
gtk_label_set_text (GTK_LABEL (priv->xmp_creator_label), NULL);
gtk_label_set_text (GTK_LABEL (priv->xmp_rights_label), NULL);
}
#endif
}
void
gnm_notebook_prev_page (GnmNotebook *nb)
{
gtk_notebook_prev_page (GTK_NOTEBOOK (nb));
}
static VALUE
rg_prev_page(VALUE self)
{
gtk_notebook_prev_page(_SELF(self));
return self;
}
IRC_Client_GUI_MessageHandler::~IRC_Client_GUI_MessageHandler ()
{
RPG_TRACE (ACE_TEXT ("IRC_Client_GUI_MessageHandler::~IRC_Client_GUI_MessageHandler"));
// sanity check(s)
ACE_ASSERT (CBData_.GTKState);
ACE_Guard<ACE_Thread_Mutex> aGuard (CBData_.GTKState->lock);
// remove queued events
while (g_idle_remove_by_data (this));
if (eventSourceID_)
{
Common_UI_GTKEventSourceIdsIterator_t iterator =
CBData_.GTKState->eventSourceIds.begin();
while (iterator != CBData_.GTKState->eventSourceIds.end())
{
if (*iterator == eventSourceID_)
{
iterator = CBData_.GTKState->eventSourceIds.erase(iterator);
continue;
} // end IF
iterator++;
}
if (iterator != CBData_.GTKState->eventSourceIds.end ())
CBData_.GTKState->eventSourceIds.erase (iterator);
} // end IF
// *NOTE*: the server log handler MUST NOT do this...
if (parent_)
{
// remove server page from parent notebook
Common_UI_GTKBuildersIterator_t iterator =
CBData_.GTKState->builders.find (builderLabel_);
// sanity check(s)
if (iterator == CBData_.GTKState->builders.end ())
{
ACE_DEBUG ((LM_ERROR,
ACE_TEXT ("handler (was: \"%s\") builder not found, returning\n"),
ACE_TEXT (builderLabel_.c_str ())));
return;
} // end IF
GtkVBox* vbox_p =
GTK_VBOX (gtk_builder_get_object ((*iterator).second.second,
ACE_TEXT_ALWAYS_CHAR ("channel_tab_vbox")));
ACE_ASSERT (vbox_p);
guint page_num = gtk_notebook_page_num (parent_,
GTK_WIDGET (vbox_p));
// flip away from "this" page ?
if (gtk_notebook_get_current_page (parent_) == static_cast<gint> (page_num))
gtk_notebook_prev_page (parent_);
// remove channel page from channel tabs notebook
gtk_notebook_remove_page (parent_,
page_num);
g_object_unref (G_OBJECT ((*iterator).second.second));
CBData_.GTKState->builders.erase (iterator);
} // end IF
}
