static gboolean
pp_layout_nup_pageview_button_press( GtkWidget *widget,
GdkEventButton *event )
{
pp_Layout_NUp_PageView *pageview;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (PP_IS_PAGEVIEW (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
pageview = PP_LAYOUT_NUP_PAGEVIEW (widget);
int x=int(event->x-pageview->left);
int y=int(event->y-pageview->top);
bool shift=(event->state&GDK_SHIFT_MASK)!=0;
bool ctrl=(event->state&GDK_CONTROL_MASK)!=0;
if(x>0 && y>0 && x<pageview->width && y<pageview->height && pageview->scale>0.0)
{
double sx=x/pageview->scale;
double sy=y/pageview->scale;
Layout_ImageInfo *prevselected=pageview->selected;
pageview->selected=pageview->layout->ImageAtCoord(int(sx),int(sy));
switch(event->button)
{
case 1:
if(!(shift||ctrl))
{
if(pageview->selected && pageview->selected->allowcropping)
{
pageview->dragging=true;
pageview->init_x=x;
pageview->init_y=y;
pageview->init_hpan=pageview->selected->crop_hpan;
pageview->init_vpan=pageview->selected->crop_vpan;
gtk_grab_add(widget);
}
else
pageview->dragging=false;
pageview->layout->SelectNone();
}
if(pageview->selected)
{
if(ctrl)
pageview->selected->ToggleSelected();
else if(shift)
{
if(prevselected)
{
LayoutIterator it(*pageview->layout);
Layout_ImageInfo *ii=it.FirstImage();
bool selecting=false;
while(ii)
{
if((ii==prevselected) || (ii==pageview->selected))
{
if(selecting)
ii->SetSelected(true);
selecting^=true;
}
if(selecting)
ii->SetSelected(true);
ii=it.NextImage();
}
}
else
pageview->selected->SetSelected(true);
}
else
pageview->selected->SetSelected(true);
}
pp_layout_nup_pageview_refresh(pageview);
g_signal_emit_by_name (GTK_OBJECT (pageview), "selection_changed");
break;
case 3:
if(!(shift||ctrl))
{
if(pageview->selected)
{
if(!pageview->selected->GetSelected())
pageview->layout->SelectNone();
}
else
pageview->layout->SelectNone();
}
if(pageview->selected)
{
pageview->selected->SetSelected(true);
pp_layout_nup_pageview_refresh(pageview);
g_signal_emit_by_name (GTK_OBJECT (pageview), "selection_changed");
g_signal_emit_by_name (GTK_OBJECT (pageview), "popupmenu");
}
break;
default:
break;
}
}
return FALSE;
}
gboolean
gtk_file_chooser_native_portal_show (GtkFileChooserNative *self)
{
FilechooserPortalData *data;
GtkWindow *transient_for;
GDBusConnection *connection;
char *parent_window_str;
GDBusMessage *message;
GVariantBuilder opt_builder;
GtkFileChooserAction action;
gboolean multiple;
const char *method_name;
if (!gtk_should_use_portal ())
return FALSE;
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
if (connection == NULL)
return FALSE;
action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (self));
multiple = gtk_file_chooser_get_select_multiple (GTK_FILE_CHOOSER (self));
if (action == GTK_FILE_CHOOSER_ACTION_OPEN)
method_name = "OpenFile";
else if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
method_name = "SaveFile";
else
{
g_warning ("GTK_FILE_CHOOSER_ACTION_%s is not supported by GtkFileChooserNativePortal", action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ? "SELECT_FOLDER" : "CREATE_FOLDER");
return FALSE;
}
data = g_new0 (FilechooserPortalData, 1);
data->self = g_object_ref (self);
data->connection = connection;
message = g_dbus_message_new_method_call ("org.freedesktop.portal.Desktop",
"/org/freedesktop/portal/desktop",
"org.freedesktop.portal.FileChooser",
method_name);
parent_window_str = NULL;
transient_for = gtk_native_dialog_get_transient_for (GTK_NATIVE_DIALOG (self));
if (transient_for != NULL && gtk_widget_is_visible (GTK_WIDGET (transient_for)))
{
GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (transient_for));
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_WINDOW(window))
parent_window_str = g_strdup_printf ("x11:%x", (guint32)gdk_x11_window_get_xid (window));
#endif
}
if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self)))
data->modal = TRUE;
if (data->modal && transient_for != NULL)
{
data->grab_widget = gtk_invisible_new_for_screen (gtk_widget_get_screen (GTK_WIDGET (transient_for)));
gtk_grab_add (GTK_WIDGET (data->grab_widget));
}
g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&opt_builder, "{sv}", "multiple",
g_variant_new_boolean (multiple));
if (self->accept_label)
g_variant_builder_add (&opt_builder, "{sv}", "accept_label",
g_variant_new_string (self->accept_label));
if (self->cancel_label)
g_variant_builder_add (&opt_builder, "{sv}", "cancel_label",
g_variant_new_string (self->cancel_label));
g_variant_builder_add (&opt_builder, "{sv}", "modal",
g_variant_new_boolean (data->modal));
g_variant_builder_add (&opt_builder, "{sv}", "filters", get_filters (GTK_FILE_CHOOSER (self)));
if (GTK_FILE_CHOOSER_NATIVE (self)->current_name)
g_variant_builder_add (&opt_builder, "{sv}", "current_name",
g_variant_new_string (GTK_FILE_CHOOSER_NATIVE (self)->current_name));
if (GTK_FILE_CHOOSER_NATIVE (self)->current_folder)
{
gchar *path;
path = g_file_get_path (GTK_FILE_CHOOSER_NATIVE (self)->current_folder);
g_variant_builder_add (&opt_builder, "{sv}", "current_folder",
g_variant_new_bytestring (path));
g_free (path);
}
if (GTK_FILE_CHOOSER_NATIVE (self)->current_file)
{
gchar *path;
path = g_file_get_path (GTK_FILE_CHOOSER_NATIVE (self)->current_file);
g_variant_builder_add (&opt_builder, "{sv}", "current_file",
g_variant_new_bytestring (path));
g_free (path);
}
if (GTK_FILE_CHOOSER_NATIVE (self)->choices)
g_variant_builder_add (&opt_builder, "{sv}", "choices",
serialize_choices (GTK_FILE_CHOOSER_NATIVE (self)));
g_dbus_message_set_body (message,
g_variant_new ("(ss@a{sv})",
parent_window_str ? parent_window_str : "",
gtk_native_dialog_get_title (GTK_NATIVE_DIALOG (self)),
g_variant_builder_end (&opt_builder)));
g_free (parent_window_str);
g_dbus_connection_send_message_with_reply (data->connection,
message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
G_MAXINT,
NULL,
NULL,
open_file_msg_cb,
data);
g_object_unref (message);
self->mode_data = data;
return TRUE;
}
// used for reading a value from user when break on value is requested
int gui_get_value(char *prompt)
{
static GtkWidget *dialog=NULL;
static GtkWidget *label;
static GtkWidget *entry;
GtkWidget *button;
GtkWidget *hbox;
int retval;
int value;
if(dialog==NULL)
{
dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog),"enter value");
// gtk_signal_connect(GTK_OBJECT(dialog),
// "configure_event",GTK_SIGNAL_FUNC(configure_event),0);
gtk_signal_connect_object(GTK_OBJECT(dialog),
"delete_event",GTK_SIGNAL_FUNC(gtk_widget_hide),(gpointer)dialog);
label=gtk_label_new("values can be entered in decimal, hexadecimal, and octal.\nFor example: 31 is the same as 0x1f and 037");
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label,FALSE,FALSE,20);
hbox = gtk_hbox_new(0,0);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,FALSE,FALSE,20);
button = gtk_button_new_with_label("OK");
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button,
FALSE,FALSE,10);
gtk_signal_connect(GTK_OBJECT(button),"clicked",
GTK_SIGNAL_FUNC(a_cb),(gpointer)&retval);
button = gtk_button_new_with_label("Cancel");
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button,
FALSE,FALSE,10);
gtk_signal_connect(GTK_OBJECT(button),"clicked",
GTK_SIGNAL_FUNC(b_cb),(gpointer)&retval);
label=gtk_label_new(prompt);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(hbox), label,
FALSE,FALSE, 20);
entry=gtk_entry_new();
gtk_widget_show(entry);
gtk_box_pack_start(GTK_BOX(hbox), entry,FALSE,FALSE,20);
}
else
{
gtk_label_set_text(GTK_LABEL(label),prompt);
}
// gtk_widget_set_uposition(GTK_WIDGET(dialog),dlg_x,dlg_y);
gtk_widget_show_now(dialog);
gtk_grab_add(dialog);
gtk_main();
gtk_grab_remove(dialog);
gtk_widget_hide(dialog);
if(retval)
{
char *end;
gchar *entry_text;
entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
value = strtoul(entry_text,&end,0);
if(*entry_text!='\0' && *end=='\0')
return value;
else
return -1;
}
return -1;
}
static gboolean
gimp_view_button_press_event (GtkWidget *widget,
GdkEventButton *bevent)
{
GimpView *view = GIMP_VIEW (widget);
#ifdef DEBUG_MEMSIZE
if (bevent->type == GDK_BUTTON_PRESS && bevent->button == 2)
{
gimp_debug_memsize = TRUE;
gimp_object_get_memsize (GIMP_OBJECT (view->viewable), NULL);
gimp_debug_memsize = FALSE;
}
#endif /* DEBUG_MEMSIZE */
if (! view->clickable &&
! view->show_popup)
return FALSE;
if (! gtk_widget_get_realized (widget))
return FALSE;
if (bevent->type == GDK_BUTTON_PRESS)
{
if (gdk_event_triggers_context_menu ((GdkEvent *) bevent))
{
view->press_state = 0;
g_signal_emit (widget, view_signals[CONTEXT], 0);
}
else if (bevent->button == 1)
{
gtk_grab_add (widget);
view->has_grab = TRUE;
view->press_state = bevent->state;
if (view->show_popup && view->viewable)
{
gimp_view_popup_show (widget, bevent,
view->renderer->context,
view->viewable,
view->renderer->width,
view->renderer->height,
view->renderer->dot_for_dot);
}
}
else
{
view->press_state = 0;
if (bevent->button == 2)
gimp_view_popup_show (widget, bevent,
view->renderer->context,
view->viewable,
view->renderer->width,
view->renderer->height,
view->renderer->dot_for_dot);
return FALSE;
}
}
else if (bevent->type == GDK_2BUTTON_PRESS)
{
if (bevent->button == 1)
g_signal_emit (widget, view_signals[DOUBLE_CLICKED], 0);
}
return view->eat_button_events ? TRUE : FALSE;
}
void
ephy_push_scroller_start (EphyPushScroller *scroller,
EphyEmbed *embed,
gdouble x,
gdouble y)
{
EphyPushScrollerPrivate *priv = scroller->priv;
GtkWidget *widget, *child;
guint32 timestamp;
g_return_if_fail (embed != NULL);
LOG ("Start [%p]", scroller);
if (priv->active) return;
if (gdk_pointer_is_grabbed ()) return;
priv->active = TRUE;
/* FIXME is this good enough? */
timestamp = gtk_get_current_event_time ();
g_object_ref (scroller);
priv->embed = embed;
g_object_ref (priv->window);
/* set positions */
priv->start_x = x;
priv->start_y = y;
g_signal_connect (priv->window, "motion-notify-event",
G_CALLBACK (ephy_push_scroller_motion_cb), scroller);
g_signal_connect (priv->window, "button-press-event",
G_CALLBACK (ephy_push_scroller_mouse_press_cb), scroller);
g_signal_connect (priv->window, "button-release-event",
G_CALLBACK (ephy_push_scroller_mouse_release_cb), scroller);
g_signal_connect (priv->window, "key-press-event",
G_CALLBACK (ephy_push_scroller_key_press_cb), scroller);
g_signal_connect (priv->window, "unmap-event",
G_CALLBACK (ephy_push_scroller_unmap_event_cb), scroller);
g_signal_connect (priv->window, "grab-broken-event",
G_CALLBACK (ephy_push_scroller_grab_broken_event_cb), scroller);
/* FIXME: this signal only seems to be emitted on the container children of GtkWindow,
* not on GtkWindow itself... is there a better way to get notified of new grabs?
*/
child = gtk_bin_get_child (GTK_BIN (priv->window));
g_signal_connect_object (child, "grab-notify",
G_CALLBACK (ephy_push_scroller_grab_notify_cb), scroller, 0);
/* grab the pointer */
widget = GTK_WIDGET (priv->window);
gtk_grab_add (widget);
if (gdk_pointer_grab (gtk_widget_get_window (widget), FALSE,
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK,
NULL, priv->cursor, timestamp) != GDK_GRAB_SUCCESS)
{
ephy_push_scroller_stop (scroller, timestamp);
return;
}
if (gdk_keyboard_grab (gtk_widget_get_window (widget), FALSE, timestamp) != GDK_GRAB_SUCCESS)
{
ephy_push_scroller_stop (scroller, timestamp);
return;
}
}
char* get_filename_from_dialog(const char* filenamechoice, int action) {
gchar* save_filename;
char* filename_return;
char* ret_val = NULL;
#ifdef USE_GTK_FILE_CHOOSER
GtkWidget* file_selection_dialog =
gtk_file_chooser_dialog_new("Please select a place to download to",
GTK_WINDOW(main_window), //meaningless?
action,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
if (filenamechoice != NULL)
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(file_selection_dialog), filenamechoice);
if (gtk_dialog_run(GTK_DIALOG(file_selection_dialog)) == GTK_RESPONSE_ACCEPT) {
save_filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(file_selection_dialog));
filename_return = (char*)malloc(strlen(save_filename) + 1);
if (filename_return == NULL) { //no memory left, maybe
return NULL; //just give up
}
strcpy(filename_return, save_filename);
gtk_widget_destroy(file_selection_dialog);
return filename_return;
} else { //user cancelled
gtk_widget_destroy(file_selection_dialog);
return NULL;
}
#else
GtkFileSelection* file_selection_box = gtk_file_selection_new("Choose a file");
gboolean confirmed = FALSE;
/* g_signal_connect (GTK_FILE_SELECTION(file_selection_box)->ok_button,
"clicked",
G_CALLBACK(store_filename),
file_selection_box);*/
// gtk_window_set_modal(GTK_WINDOW(file_selection_box), TRUE);
gtk_signal_connect (GTK_OBJECT (file_selection_box), "delete_event",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_signal_connect (GTK_OBJECT (file_selection_box->ok_button), "clicked",
GTK_SIGNAL_FUNC(file_selection_ok),
&confirmed);
gtk_signal_connect (GTK_OBJECT (file_selection_box->cancel_button), "clicked",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_window_set_modal (GTK_WINDOW (file_selection_box), TRUE);
gtk_widget_show(GTK_WIDGET(file_selection_box));
gtk_grab_add (GTK_WIDGET (file_selection_box));
gtk_main ();
if (confirmed) {
ret_val = store_filename(file_selection_box);
} else {
ret_val = NULL;
}
gtk_widget_destroy(file_selection_box);
return ret_val;
#endif
}
static GtkCellEditable *
gtk_cell_renderer_accel_start_editing (GtkCellRenderer *cell,
GdkEvent *event,
GtkWidget *widget,
const gchar *path,
GdkRectangle *background_area,
GdkRectangle *cell_area,
GtkCellRendererState flags)
{
GtkCellRendererText *celltext;
GtkCellRendererAccel *accel;
GtkWidget *label;
GtkWidget *eventbox;
celltext = GTK_CELL_RENDERER_TEXT (cell);
accel = GTK_CELL_RENDERER_ACCEL (cell);
/* If the cell isn't editable we return NULL. */
if (celltext->editable == FALSE)
return NULL;
g_return_val_if_fail (widget->window != NULL, NULL);
if (gdk_keyboard_grab (widget->window, FALSE,
gdk_event_get_time (event)) != GDK_GRAB_SUCCESS)
return NULL;
if (gdk_pointer_grab (widget->window, FALSE,
GDK_BUTTON_PRESS_MASK,
NULL, NULL,
gdk_event_get_time (event)) != GDK_GRAB_SUCCESS)
{
gdk_display_keyboard_ungrab (gtk_widget_get_display (widget),
gdk_event_get_time (event));
return NULL;
}
accel->grab_widget = widget;
g_signal_connect (G_OBJECT (widget), "key-press-event",
G_CALLBACK (grab_key_callback),
accel);
eventbox = g_object_new (_gtk_cell_editable_event_box_get_type (), NULL);
accel->edit_widget = eventbox;
g_object_add_weak_pointer (G_OBJECT (accel->edit_widget),
(gpointer) &accel->edit_widget);
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL,
&widget->style->bg[GTK_STATE_SELECTED]);
gtk_widget_modify_fg (label, GTK_STATE_NORMAL,
&widget->style->fg[GTK_STATE_SELECTED]);
/* This label is displayed in a treeview cell displaying
* an accelerator when the cell is clicked to change the
* acelerator.
*/
gtk_label_set_text (GTK_LABEL (label), _("New accelerator..."));
gtk_container_add (GTK_CONTAINER (eventbox), label);
g_object_set_data_full (G_OBJECT (accel->edit_widget), "gtk-cell-renderer-text",
g_strdup (path), g_free);
gtk_widget_show_all (accel->edit_widget);
gtk_grab_add (accel->grab_widget);
g_signal_connect (G_OBJECT (accel->edit_widget), "unrealize",
G_CALLBACK (ungrab_stuff), accel);
return GTK_CELL_EDITABLE (accel->edit_widget);
}
void XAP_UnixDialog_FileOpenSaveAs::runModal(XAP_Frame * pFrame)
{
const XAP_StringSet * pSS = m_pApp->getStringSet();
std::string szTitle;
std::string szFileTypeLabel;
switch (m_id)
{
case XAP_DIALOG_ID_INSERT_PICTURE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_IP_Title, szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel, szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_FILE_OPEN:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_OpenTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_FILE_IMPORT:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ImportTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_INSERTMATHML:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertMath,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileInsertMath,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_INSERTOBJECT:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertObject,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileInsertObject,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_INSERT_FILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_FILE_SAVEAS:
case XAP_DIALOG_ID_FILE_SAVE_IMAGE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_SaveAsTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileSaveTypeLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_FILE_EXPORT:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ExportTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileSaveTypeLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_PRINTTOFILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_PrintToFileTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FilePrintTypeLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_RECORDTOFILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_RecordToFileTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_RecordToFileLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_REPLAYFROMFILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ReplayFromFileTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ReplayFromFileLabel,szFileTypeLabel);
m_bSave = false;
break;
}
default:
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
m_bSave = false;
break;
}
// NOTE: we use our string mechanism to localize the dialog's
// NOTE: title and the error/confirmation message boxes. we
// NOTE: let GTK take care of the localization of the actual
// NOTE: buttons and labels on the FileSelection dialog.
// Get the GtkWindow of the parent frame
XAP_UnixFrameImpl * pUnixFrameImpl = static_cast<XAP_UnixFrameImpl *>(pFrame->getFrameImpl());
GtkWidget * parent = pUnixFrameImpl->getTopLevelWindow();
if(parent && (GTK_WIDGET_TOPLEVEL(parent) != TRUE))
{
parent = gtk_widget_get_toplevel (parent);
}
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
m_FC = GTK_FILE_CHOOSER( hildon_file_chooser_dialog_new(GTK_WINDOW(parent),
(!m_bSave ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE))
);
#else
m_FC = GTK_FILE_CHOOSER( gtk_file_chooser_dialog_new (szTitle.c_str(),
GTK_WINDOW(parent),
(!m_bSave ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
(m_bSave ? GTK_STOCK_SAVE : GTK_STOCK_OPEN), GTK_RESPONSE_ACCEPT,
(gchar*)NULL)
);
#endif
gtk_file_chooser_set_local_only(m_FC, FALSE);
abiSetupModalDialog(GTK_DIALOG(m_FC), pFrame, this, GTK_RESPONSE_ACCEPT);
GtkWidget * filetypes_pulldown = NULL;
std::string s;
/*
Add a drop-down list of known types to facilitate a file-types selection.
We store an indexer in the user data for each menu item in the popup, so
we can read the type we need to return.
*/
if (m_id == XAP_DIALOG_ID_INSERT_PICTURE)
{
GtkWidget * preview = createDrawingArea ();
gtk_widget_show (preview);
m_preview = preview;
gtk_widget_set_size_request (preview, PREVIEW_WIDTH, PREVIEW_HEIGHT);
// place the preview area inside a container to get a nice border
GtkWidget * preview_hbox = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER(preview_hbox), 4);
gtk_box_pack_start(GTK_BOX(preview_hbox), preview, TRUE, TRUE, 0);
// attach the preview area to the dialog
gtk_file_chooser_set_preview_widget (m_FC, preview_hbox);
gtk_file_chooser_set_preview_widget_active (m_FC, true);
// connect some signals
g_signal_connect (m_FC, "update_preview",
G_CALLBACK (file_selection_changed), static_cast<gpointer>(this));
g_signal_connect (preview, "expose_event",
G_CALLBACK (s_preview_exposed), static_cast<gpointer>(this));
}
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
filetypes_pulldown = gtk_combo_box_new();
gtk_widget_show(filetypes_pulldown);
GtkWidget * pulldown_hbox = filetypes_pulldown;
#else
// hbox for our pulldown menu (GTK does its pulldown this way */
GtkWidget * pulldown_hbox = gtk_hbox_new(FALSE, 15);
gtk_widget_show(pulldown_hbox);
// pulldown label
GtkWidget * filetypes_label = gtk_label_new_with_mnemonic(convertMnemonics(szFileTypeLabel).c_str());
gtk_label_set_justify(GTK_LABEL(filetypes_label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment(GTK_MISC(filetypes_label), 1.0, 0.5);
gtk_widget_show(filetypes_label);
gtk_box_pack_start(GTK_BOX(pulldown_hbox), filetypes_label, TRUE, TRUE, 0);
// pulldown menu
filetypes_pulldown = gtk_combo_box_new();
gtk_widget_show(filetypes_pulldown);
gtk_box_pack_end(GTK_BOX(pulldown_hbox), filetypes_pulldown, TRUE, TRUE, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(filetypes_label), filetypes_pulldown);
#endif
//
// add the filters to the dropdown list
//
GtkComboBox* combo = GTK_COMBO_BOX(filetypes_pulldown);
XAP_makeGtkComboBoxText(combo, G_TYPE_INT);
// Auto-detect is always an option, but a special one, so we use
// a pre-defined constant for the type, and don't use the user-supplied
// types yet.
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileTypeAutoDetect,s);
XAP_appendComboBoxTextAndInt(combo, s.c_str(), XAP_DIALOG_FILEOPENSAVEAS_FILE_TYPE_AUTO);
UT_sint32 activeItemIndex = -1;
// add list items
{
UT_ASSERT(g_strv_length((gchar **) m_szSuffixes) == g_strv_length((gchar **) m_szDescriptions));
// measure one list, they should all be the same length
UT_uint32 end = g_strv_length((gchar **) m_szDescriptions);
for (UT_uint32 i = 0; i < end; i++)
{
// If this type is default, save its index (i) for later use
if (m_nTypeList[i] == m_nDefaultFileType)
activeItemIndex = i;
XAP_appendComboBoxTextAndInt(combo, m_szDescriptions[i], m_nTypeList[i]);
//
// Attach a callback when it is activated to change the file suffix
//
// g_signal_connect(G_OBJECT(thismenuitem), "activate",
// G_CALLBACK(s_filetypechanged),
// reinterpret_cast<gpointer>(this));
}
}
m_wFileTypes_PullDown = filetypes_pulldown;
// dialog; open dialog always does auto-detect
// TODO: should this also apply to the open dialog?
if (m_id == XAP_DIALOG_ID_FILE_SAVEAS || m_id == XAP_DIALOG_ID_FILE_SAVE_IMAGE)
{
gtk_combo_box_set_active(combo, activeItemIndex + 1);
}
else
{
gtk_combo_box_set_active(combo, 0);
}
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
hildon_file_chooser_dialog_add_extra ((HildonFileChooserDialog*)m_FC,
pulldown_hbox);
#else
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(m_FC), pulldown_hbox);
#endif
// connect the signals for OK and CANCEL and the requisite clean-close signals
g_signal_connect(G_OBJECT(m_FC),
"delete-event",
G_CALLBACK(s_delete_clicked),
this);
g_signal_connect(G_OBJECT(m_FC),
"key_press_event",
G_CALLBACK(fsel_key_event), &m_answer);
g_signal_connect (G_OBJECT (m_FC),
"response",
G_CALLBACK(dialog_response), &m_answer);
g_signal_connect (G_OBJECT (m_FC),
"file-activated",
G_CALLBACK(s_file_activated), &m_answer);
g_signal_connect(G_OBJECT(filetypes_pulldown), "changed",
G_CALLBACK(s_filetypechanged),
reinterpret_cast<gpointer>(this));
// use the persistence info and/or the suggested filename
// to properly seed the dialog.
gchar * szPersistDirectory = NULL; // we must g_free this
if (!m_szInitialPathname || !*m_szInitialPathname)
{
// the caller did not supply initial pathname
// (or supplied an empty one). see if we have
// some persistent info.
UT_ASSERT(!m_bSuggestName);
if (m_szPersistPathname)
{
// we have a pathname from a previous use,
// extract the directory portion and start
// the dialog there (but without a filename).
szPersistDirectory = UT_go_dirname_from_uri(m_szPersistPathname, FALSE);
gtk_file_chooser_set_current_folder_uri(m_FC, szPersistDirectory);
}
else
{
// no initial pathname given and we don't have
// a pathname from a previous use, so just let
// it come up in the current working directory.
}
}
else
{
// we have an initial pathname (the name of the document
// in the frame that we were invoked on). if the caller
// wanted us to suggest a filename, use the initial
// pathname as is. if not, use the directory portion of
// it.
if (m_bSuggestName)
{
xxx_UT_DEBUGMSG(("Iniitial filename is %s \n",m_szInitialPathname));
#if 0
if (!g_path_is_absolute (m_szInitialPathname)) { // DAL: todo: is this correct?
gchar *dir = g_get_current_dir ();
gchar *file = m_szInitialPathname;
gchar *filename = g_build_filename (dir, file, (gchar *)NULL);
m_szInitialPathname = UT_go_filename_to_uri(filename);
g_free(filename);
g_free (dir);
g_free (file);
}
#endif
if(m_id == XAP_DIALOG_ID_FILE_SAVEAS)
{
std::string szInitialSuffix = UT_pathSuffix(m_szInitialPathname);
std::string szSaveTypeSuffix = IE_Exp::preferredSuffixForFileType(m_nDefaultFileType).utf8_str();
if(!szInitialSuffix.empty() && !szSaveTypeSuffix.empty()
&& (szSaveTypeSuffix != szInitialSuffix))
{
std::string sFileName = m_szInitialPathname;
std::string::size_type i = sFileName.find_last_of('.');
if(i != std::string::npos)
{
// erase to the end()
sFileName.erase(i);
sFileName += szSaveTypeSuffix;
FREEP(m_szInitialPathname);
m_szInitialPathname = g_strdup(sFileName.c_str());
}
}
}
if (UT_go_path_is_uri(m_szInitialPathname) || UT_go_path_is_path(m_szInitialPathname))
{
gtk_file_chooser_set_uri(m_FC, m_szInitialPathname);
}
}
else
{
if (UT_go_path_is_uri(m_szInitialPathname) || UT_go_path_is_path(m_szInitialPathname))
{
szPersistDirectory = UT_go_dirname_from_uri(m_szInitialPathname, FALSE);
gtk_file_chooser_set_current_folder_uri(m_FC, szPersistDirectory);
}
else
{
// we are dealing with a plain filename, not an URI or path, so
// just let it come up in the current working directory.
}
}
}
// center the dialog
xxx_UT_DEBUGMSG(("before center IS WIDGET_TOP_LEVL %d \n",(GTK_WIDGET_TOPLEVEL(parent))));
xxx_UT_DEBUGMSG(("before center IS WIDGET WINDOW %d \n",(GTK_IS_WINDOW(parent))));
centerDialog(parent, GTK_WIDGET(m_FC));
xxx_UT_DEBUGMSG(("After center IS WIDGET WINDOW %d \n",(GTK_IS_WINDOW(parent))));
gtk_widget_show(GTK_WIDGET(m_FC));
gtk_grab_add(GTK_WIDGET(m_FC));
bool bResult = _run_gtk_main(pFrame,filetypes_pulldown);
if (bResult)
{
UT_ASSERT(m_szFinalPathnameCandidate);
// store final path name and file type
m_szFinalPathname = g_strdup(m_szFinalPathnameCandidate);
FREEP(m_szFinalPathnameCandidate);
// what a long ugly line of code
m_nFileType = XAP_comboBoxGetActiveInt(GTK_COMBO_BOX(filetypes_pulldown));
}
if (m_FC != NULL) {
gtk_grab_remove (GTK_WIDGET(m_FC));
gtk_widget_destroy (GTK_WIDGET(m_FC));
m_FC = NULL;
FREEP(szPersistDirectory);
}
return;
}
/*
* GetFilename
*
* Show a dialog with a title and if "Ok" is selected
* call the function with the name of the file.
*/
void GetFilename (char *sTitle, void (*callback) (char *),char *selected, char *filter, int opid)
{
typFileSelectionData *data;
GtkWidget *filterbutton;
GtkWidget *optionmenu1, *optionmenu1_menu, *menuitem;
filew=NULL;
tbflag=TRUE;
/* --- Create a new file selection widget --- */
filew = gtk_file_selection_new (sTitle);
gtk_file_selection_show_fileop_buttons(GTK_FILE_SELECTION(filew));
data = g_malloc (sizeof (typFileSelectionData));
data->func = callback;
data->filesel = filew;
data->opid = opid;
gtk_file_selection_set_filename(GTK_FILE_SELECTION(filew),selected);
gtk_signal_connect (GTK_OBJECT (filew), "destroy",
(GtkSignalFunc) destroy, data);
/////////////////////////////////////////////////////////////////
*filt=0;
strcat(filt, "show only ");
strcat(filt, filter);
strcat(filt, " files / show all");
if (strcmp(filter,"*.ats")==0) {
filterbutton= gtk_button_new_with_label (filt);
*filt=0;
filt = g_strdup (filter);
gtk_box_pack_start (GTK_BOX(GTK_FILE_SELECTION(filew)->action_area), filterbutton, TRUE, TRUE, 0);
gtk_widget_show(filterbutton);
gtk_signal_connect (GTK_OBJECT (filterbutton), "clicked",GTK_SIGNAL_FUNC(set_filter),(char *)filt);
}
if (strcmp(filter,"*.apf")==0) {
filterbutton= gtk_button_new_with_label (filt);
*filt=0;
filt = g_strdup (filter);
gtk_box_pack_start (GTK_BOX(GTK_FILE_SELECTION(filew)->action_area), filterbutton, TRUE, TRUE, 0);
gtk_widget_show(filterbutton);
gtk_signal_connect (GTK_OBJECT (filterbutton), "clicked",GTK_SIGNAL_FUNC(set_filter),(char *)filt);
}
if (strcmp(filter,"*.wav")==0 || strcmp(filter,"*.aif")==0 || strcmp(filter,"*.snd")==0 ) {
if(opid!=RES_OUTSEL) {
////////OPTION MENU///////////////////////////////////////
optionmenu1 = gtk_option_menu_new ();
gtk_widget_ref (optionmenu1);
gtk_object_set_data_full (GTK_OBJECT (filew), "optionmenu1", optionmenu1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (optionmenu1);
gtk_box_pack_start (GTK_BOX(GTK_FILE_SELECTION(filew)->action_area),optionmenu1,
TRUE, TRUE, 0);
optionmenu1_menu = gtk_menu_new ();
menuitem = create_men_snd("16 bits shorts WAV file", 0, optionmenu1_menu);
menuitem = create_men_snd("32 bits floats WAV file", 1, optionmenu1_menu);
menuitem = create_men_snd("16 bits shorts AIF file", 2, optionmenu1_menu);
menuitem = create_men_snd("16 bits shorts SND file", 3, optionmenu1_menu);
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), optionmenu1_menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu1), (int)outype);
gtk_widget_set_usize (optionmenu1, 100, 25);
}
else { //residual output soundfile can only be WAV
filterbutton= gtk_button_new_with_label (filt);
*filt=0;
filt = g_strdup (filter);
gtk_box_pack_start (GTK_BOX(GTK_FILE_SELECTION(filew)->action_area), filterbutton, TRUE, TRUE, 0);
gtk_widget_show(filterbutton);
gtk_signal_connect (GTK_OBJECT (filterbutton), "clicked",GTK_SIGNAL_FUNC(set_filter),(char *)filt);
}
}
////////////////////////////////////////////////////////////
slabel= gtk_label_new (selected);
gtk_box_pack_start (GTK_BOX(GTK_FILE_SELECTION(filew)->action_area), slabel, TRUE, TRUE, 0);
gtk_widget_show(slabel);
/* --- Connect the "ok" button --- */
gtk_signal_connect(GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
"clicked", (GtkSignalFunc) FileOk, data);
/* --- Connect the cancel button --- */
gtk_signal_connect_object (
GTK_OBJECT (GTK_FILE_SELECTION (filew)->cancel_button),
"clicked", (GtkSignalFunc) gtk_widget_destroy,
(gpointer) filew);
gtk_window_set_position(GTK_WINDOW(filew),GTK_WIN_POS_CENTER);
/* --- Show the dialog --- */
gtk_widget_show (filew);
/* --- Grab the focus. --- */
gtk_grab_add (filew);
}
static gboolean
gimp_scrolled_preview_area_event (GtkWidget *area,
GdkEvent *event,
GimpScrolledPreview *preview)
{
GimpScrolledPreviewPrivate *priv = GIMP_SCROLLED_PREVIEW_GET_PRIVATE (preview);
GdkEventButton *button_event = (GdkEventButton *) event;
GdkCursor *cursor;
switch (event->type)
{
case GDK_BUTTON_PRESS:
switch (button_event->button)
{
case 1:
case 2:
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (area),
GDK_FLEUR);
if (gdk_pointer_grab (gtk_widget_get_window (area), TRUE,
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK,
NULL, cursor,
gdk_event_get_time (event)) == GDK_GRAB_SUCCESS)
{
gtk_widget_get_pointer (area, &priv->drag_x, &priv->drag_y);
priv->drag_xoff = GIMP_PREVIEW (preview)->xoff;
priv->drag_yoff = GIMP_PREVIEW (preview)->yoff;
priv->in_drag = TRUE;
gtk_grab_add (area);
}
gdk_cursor_unref (cursor);
break;
case 3:
return TRUE;
}
break;
case GDK_BUTTON_RELEASE:
if (priv->in_drag &&
(button_event->button == 1 || button_event->button == 2))
{
gdk_display_pointer_ungrab (gtk_widget_get_display (area),
gdk_event_get_time (event));
gtk_grab_remove (area);
priv->in_drag = FALSE;
}
break;
case GDK_MOTION_NOTIFY:
if (priv->in_drag)
{
GdkEventMotion *mevent = (GdkEventMotion *) event;
GtkAdjustment *hadj;
GtkAdjustment *vadj;
gint x, y;
hadj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr));
vadj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr));
gtk_widget_get_pointer (area, &x, &y);
x = priv->drag_xoff - (x - priv->drag_x);
y = priv->drag_yoff - (y - priv->drag_y);
x = CLAMP (x,
gtk_adjustment_get_lower (hadj),
gtk_adjustment_get_upper (hadj) -
gtk_adjustment_get_page_size (hadj));
y = CLAMP (y,
gtk_adjustment_get_lower (vadj),
gtk_adjustment_get_upper (vadj) -
gtk_adjustment_get_page_size (vadj));
if (GIMP_PREVIEW (preview)->xoff != x ||
GIMP_PREVIEW (preview)->yoff != y)
{
gtk_adjustment_set_value (hadj, x);
gtk_adjustment_set_value (vadj, y);
gimp_preview_draw (GIMP_PREVIEW (preview));
gimp_preview_invalidate (GIMP_PREVIEW (preview));
}
gdk_event_request_motions (mevent);
}
break;
case GDK_SCROLL:
{
GdkEventScroll *sevent = (GdkEventScroll *) event;
GdkScrollDirection direction = sevent->direction;
GtkAdjustment *adj;
gfloat value;
/* Ctrl-Scroll is reserved for zooming */
if (sevent->state & GDK_CONTROL_MASK)
return FALSE;
if (sevent->state & GDK_SHIFT_MASK)
switch (direction)
{
case GDK_SCROLL_UP: direction = GDK_SCROLL_LEFT; break;
case GDK_SCROLL_DOWN: direction = GDK_SCROLL_RIGHT; break;
case GDK_SCROLL_LEFT: direction = GDK_SCROLL_UP; break;
case GDK_SCROLL_RIGHT: direction = GDK_SCROLL_DOWN; break;
}
switch (direction)
{
case GDK_SCROLL_UP:
case GDK_SCROLL_DOWN:
default:
adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr));
break;
case GDK_SCROLL_RIGHT:
case GDK_SCROLL_LEFT:
adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr));
break;
}
value = gtk_adjustment_get_value (adj);
switch (direction)
{
case GDK_SCROLL_UP:
case GDK_SCROLL_LEFT:
value -= gtk_adjustment_get_page_increment (adj) / 2;
break;
case GDK_SCROLL_DOWN:
case GDK_SCROLL_RIGHT:
value += gtk_adjustment_get_page_increment (adj) / 2;
break;
}
gtk_adjustment_set_value (adj,
CLAMP (value,
gtk_adjustment_get_lower (adj),
gtk_adjustment_get_upper (adj) -
gtk_adjustment_get_page_size (adj)));
}
break;
default:
break;
}
return FALSE;
}
static gboolean
gimp_scrolled_preview_nav_button_press (GtkWidget *widget,
GdkEventButton *event,
GimpScrolledPreview *preview)
{
GimpPreview *gimp_preview = GIMP_PREVIEW (preview);
GtkAdjustment *adj;
if (preview->nav_popup)
return TRUE;
if (event->type == GDK_BUTTON_PRESS && event->button == 1)
{
GtkStyle *style = gtk_widget_get_style (widget);
GtkWidget *outer;
GtkWidget *inner;
GtkWidget *area;
GdkCursor *cursor;
gint x, y;
gdouble h, v;
preview->nav_popup = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (preview->nav_popup),
gtk_widget_get_screen (widget));
outer = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (outer), GTK_SHADOW_OUT);
gtk_container_add (GTK_CONTAINER (preview->nav_popup), outer);
gtk_widget_show (outer);
inner = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (inner), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (outer), inner);
gtk_widget_show (inner);
area = g_object_new (GIMP_TYPE_PREVIEW_AREA,
"check-size", GIMP_CHECK_SIZE_SMALL_CHECKS,
"check-type", GIMP_PREVIEW_AREA (gimp_preview->area)->check_type,
NULL);
gtk_container_add (GTK_CONTAINER (inner), area);
g_signal_connect (area, "event",
G_CALLBACK (gimp_scrolled_preview_nav_popup_event),
preview);
g_signal_connect_after (area, "expose-event",
G_CALLBACK (gimp_scrolled_preview_nav_popup_expose),
preview);
GIMP_PREVIEW_GET_CLASS (preview)->draw_thumb (gimp_preview,
GIMP_PREVIEW_AREA (area),
POPUP_SIZE, POPUP_SIZE);
gtk_widget_realize (area);
gtk_widget_show (area);
gdk_window_get_origin (gtk_widget_get_window (widget), &x, &y);
adj = gtk_range_get_adjustment (GTK_RANGE (preview->hscr));
h = ((gtk_adjustment_get_value (adj) /
gtk_adjustment_get_upper (adj)) +
(gtk_adjustment_get_page_size (adj) /
gtk_adjustment_get_upper (adj)) / 2.0);
adj = gtk_range_get_adjustment (GTK_RANGE (preview->vscr));
v = ((gtk_adjustment_get_value (adj) /
gtk_adjustment_get_upper (adj)) +
(gtk_adjustment_get_page_size (adj) /
gtk_adjustment_get_upper (adj)) / 2.0);
x += event->x - h * (gdouble) GIMP_PREVIEW_AREA (area)->width;
y += event->y - v * (gdouble) GIMP_PREVIEW_AREA (area)->height;
gtk_window_move (GTK_WINDOW (preview->nav_popup),
x - 2 * style->xthickness,
y - 2 * style->ythickness);
gtk_widget_show (preview->nav_popup);
gtk_grab_add (area);
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
GDK_FLEUR);
gdk_pointer_grab (gtk_widget_get_window (area), TRUE,
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK,
gtk_widget_get_window (area), cursor,
event->time);
gdk_cursor_unref (cursor);
}
return TRUE;
}
static VALUE
rg_m_grab_add(G_GNUC_UNUSED VALUE self, VALUE widget)
{
gtk_grab_add(GTK_WIDGET(RVAL2GOBJ(widget)));
return Qnil;
}
/*
* Popup
*
* Display a popup dialog window with a message and an
* "Ok" button
*/
void Popup (char *szMessage)
{
static GtkWidget *label;
GtkWidget *button;
GtkWidget *dialog_window;
/* --- Create a dialog window --- */
dialog_window = gtk_dialog_new ();
gtk_window_set_policy(GTK_WINDOW (dialog_window),FALSE,FALSE,FALSE);
/* --- Trap the window close signal to release the grab --- */
gtk_signal_connect (GTK_OBJECT (dialog_window), "destroy",
GTK_SIGNAL_FUNC (ClosingDialog),
&dialog_window);
/* --- Add a title to the window --- */
gtk_window_set_title (GTK_WINDOW (dialog_window), "HEY...!!!");
/* --- Create a small border --- */
gtk_container_border_width (GTK_CONTAINER (dialog_window), 5);
/*
* --- Create the message
*/
/* --- Create the message in a label --- */
label = gtk_label_new (szMessage);
/* --- Put some room around the label --- */
gtk_misc_set_padding (GTK_MISC (label), 10, 10);
/* --- Add the label to the dialog --- */
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->vbox),
label, TRUE, TRUE, 0);
/* --- Make the label visible --- */
gtk_widget_show (label);
/*
* --- "ok" button
*/
/* --- Create the "ok" button --- */
button = gtk_button_new_with_label ("Ok");
/* --- Need to close the window if they press "ok" --- */
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (CloseDialog),
dialog_window);
/* --- Allow it to be the default button --- */
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
/* --- Add the button to the dialog --- */
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_window)->action_area),
button, TRUE, TRUE, 0);
/* --- Make the button the default button --- */
gtk_widget_grab_default (button);
/* --- Make the button visible --- */
gtk_widget_show (button);
/* --- Make the dialog visible --- */
gtk_window_set_position(GTK_WINDOW(dialog_window),GTK_WIN_POS_CENTER);
gtk_widget_show (dialog_window);
gtk_grab_add (dialog_window);
}
int DoLoadPortalFileDialog ()
{
GtkWidget *dlg, *vbox, *hbox, *button, *entry, *check2d, *check3d;
int loop = 1, ret = IDCANCEL;
dlg = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (dlg), "Load .prt");
gtk_signal_connect (GTK_OBJECT (dlg), "delete_event",
GTK_SIGNAL_FUNC (dialog_delete_callback), NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroy), NULL);
g_object_set_data (G_OBJECT (dlg), "loop", &loop);
g_object_set_data (G_OBJECT (dlg), "ret", &ret);
vbox = gtk_vbox_new (FALSE, 5);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (dlg), vbox);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
entry = gtk_entry_new ();
gtk_widget_show (entry);
gtk_entry_set_editable (GTK_ENTRY (entry), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
hbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
check3d = gtk_check_button_new_with_label ("Show 3D");
gtk_widget_show (check3d);
gtk_box_pack_start (GTK_BOX (hbox), check3d, FALSE, FALSE, 0);
check2d = gtk_check_button_new_with_label ("Show 2D");
gtk_widget_show (check2d);
gtk_box_pack_start (GTK_BOX (hbox), check2d, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Change");
gtk_widget_show (button);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC (change_clicked), entry);
gtk_widget_set_usize (button, 60, -2);
hbox = gtk_hbox_new (FALSE, 5);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Cancel");
gtk_widget_show (button);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDCANCEL));
gtk_widget_set_usize (button, 60, -2);
button = gtk_button_new_with_label ("OK");
gtk_widget_show (button);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDOK));
gtk_widget_set_usize (button, 60, -2);
strcpy (portals.fn, g_FuncTable.m_pfnGetMapName());
char* fn = strrchr (portals.fn, '.');
if (fn != NULL)
{
strcpy(fn, ".prt");
}
gtk_entry_set_text (GTK_ENTRY (entry), portals.fn);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check2d), portals.show_2d);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check3d), portals.show_3d);
gtk_grab_add (dlg);
gtk_widget_show (dlg);
while (loop)
gtk_main_iteration ();
if (ret == IDOK)
{
portals.Purge();
portals.show_3d = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check3d)) ? qtrue : qfalse;
portals.show_2d = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check2d)) ? qtrue : qfalse;
}
gtk_grab_remove (dlg);
gtk_widget_destroy (dlg);
return ret;
}
static void ok_callback(GtkWidget *widget, GtkWidget *nothing)
{
int i;
struct symchain *symc, *symc_current;
gfloat interval;
if(is_append_running) return;
is_append_running = ~0;
gtk_grab_add(widget);
symc=NULL;
GTK_ADJUSTMENT(pdata->adj)->upper = (gfloat)((num_rows>1)?num_rows-1:1);
interval = (gfloat)(num_rows/100.0);
pdata->oldvalue = -1.0;
for(i=0;i<num_rows;i++)
{
int len;
struct symbol *s, *t;
s=(struct symbol *)gtk_clist_get_row_data(GTK_CLIST(clist), i);
if(s->selected)
{
pdata->value = i;
if(((int)(pdata->value/interval))!=((int)(pdata->oldvalue/interval)))
{
gtk_progress_set_value (GTK_PROGRESS (pdata->pbar), i);
while (gtk_events_pending()) gtk_main_iteration();
}
pdata->oldvalue = i;
if((!s->vec_root)||(!autocoalesce))
{
AddNode(s->n, NULL);
}
else
{
len=0;
t=s->vec_root;
while(t)
{
if(t->selected)
{
if(len) t->selected=0;
symc_current=(struct symchain *)calloc_2(1,sizeof(struct symchain));
symc_current->next=symc;
symc_current->symbol=t;
symc=symc_current;
}
len++;
t=t->vec_chain;
}
if(len)add_vector_chain(s->vec_root, len);
}
}
}
while(symc)
{
symc->symbol->selected=1;
symc_current=symc;
symc=symc->next;
free_2(symc_current);
}
MaxSignalLength();
signalarea_configure_event(signalarea, NULL);
wavearea_configure_event(wavearea, NULL);
gtk_progress_set_value (GTK_PROGRESS (pdata->pbar), 0.0);
pdata->oldvalue = -1.0;
gtk_grab_remove(widget);
is_append_running=0;
}
/*
* Función listarDireccionWindow()
*/
void listarDireccionWindow (void)
{
int i, num, ret, indice;
char *nombre, *direccion, *telefono;
GtkWidget *datos[NUM_LETRAS];
GtkWidget *window;
GtkWidget *libro;
GtkWidget *label;
GtkWidget *scroll;
char* dir[3];
char letras[NUM_LETRAS][2]={"#","A","B","C","D","E","F","G","H","I","J","K","L","M","N","Ñ","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
char inicial;
/*
* Dialog
*/
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize (GTK_WIDGET (window), 585, 300);
gtk_window_set_policy(GTK_WINDOW (window), TRUE, TRUE, FALSE);
gtk_window_set_title (GTK_WINDOW (window), "Libro de direcciones");
gtk_container_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_uposition( window, 300, 300 );
libro=gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(libro),GTK_POS_TOP);
for (indice=0;indice<NUM_LETRAS;indice++) {
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC,GTK_POLICY_ALWAYS);
datos[indice]=gtk_clist_new(3);
gtk_container_add(GTK_CONTAINER(scroll), datos[indice]);
gtk_clist_set_column_title(GTK_CLIST(datos[indice]),0,"Nombre");
gtk_clist_set_column_title(GTK_CLIST(datos[indice]),1,"Direccion");
gtk_clist_set_column_title(GTK_CLIST(datos[indice]),2,"Telefono");
gtk_clist_column_titles_show(GTK_CLIST(datos[indice]));
gtk_clist_set_column_width(GTK_CLIST(datos[indice]),0,175);
gtk_clist_set_column_width(GTK_CLIST(datos[indice]),1,250);
gtk_clist_set_column_width(GTK_CLIST(datos[indice]),2,75);
label=gtk_label_new(letras[indice]);
gtk_widget_set_usize(label,10,10);
gtk_notebook_append_page((GtkNotebook*)libro,scroll,label);
}
num=numeroDir((&datosAgenda.direcciones));
gtk_container_add (GTK_CONTAINER (window),libro);
for (i=0; i<num; i++) {
ret = consultarDir((&datosAgenda.direcciones),i,&nombre,
&direccion, &telefono);
if (0 == ret) {
dir[0]=stringDup(nombre);
dir[1]=stringDup(direccion);
dir[2]=stringDup(telefono);
/*
* Buscamos en el array de letras, la inicial del nombre.
* Insertaremos sus datos en la lista correspondiente.
*/
inicial=toupper(nombre[0]);
indice=NUM_LETRAS-1;
while ( (letras[indice][0]!=inicial) && (0 < indice) ) {
indice--;
}
gtk_clist_append(GTK_CLIST(datos[indice]),dir);
}
}
gtk_grab_add(window);
gtk_widget_show_all(window);
}
static void enter_callback(GtkWidget *widget, GtkWidget *do_warning)
{
GtkCList *cl;
gchar *entry_text;
char *entry_suffixed;
int len;
int i, j, k, row;
int pixlen, maxpixlen;
char *s, *tmp2;
gfloat interval;
if(is_searching_running) return;
is_searching_running = ~0;
gtk_grab_add(widget);
pixlen=0; maxpixlen=0;
entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
DEBUG(printf("Entry contents: %s\n", entry_text));
/* if(!(len=strlen(entry_text))) searchbox_text=NULL; */
if(!(len=strlen(entry_text))) searchbox_text=&default_null_searchbox_text;
else strcpy((searchbox_text=(char *)malloc_2(len+1)),entry_text);
num_rows=0;
gtk_clist_freeze(cl=GTK_CLIST(clist));
gtk_clist_clear(cl);
entry_suffixed=wave_alloca(strlen(entry_text)+strlen(regex_type[regex_which])+1+((regex_which<2)?2:0));
*entry_suffixed=0x00;
if(regex_which<2) strcpy(entry_suffixed, "\\<"); /* match on word boundary */
strcat(entry_suffixed,entry_text);
strcat(entry_suffixed,regex_type[regex_which]);
wave_regex_compile(entry_suffixed);
for(i=0;i<numfacs;i++)
{
facs[i]->selected=0;
}
GTK_ADJUSTMENT(pdata->adj)->upper = (gfloat)((numfacs>1)?numfacs-1:1);
pdata->oldvalue = -1.0;
interval = (gfloat)(numfacs/100.0);
for(i=0;i<numfacs;i++)
{
pdata->value = i;
if(((int)(pdata->value/interval))!=((int)(pdata->oldvalue/interval)))
{
gtk_progress_set_value (GTK_PROGRESS (pdata->pbar), i);
while (gtk_events_pending()) gtk_main_iteration();
}
pdata->oldvalue = i;
if(wave_regex_match(facs[i]->name))
{
if(!facs[i]->vec_root)
{
row=gtk_clist_append(cl,(gchar **)&(facs[i]->name));
pixlen=gdk_string_measure(signalfont,(gchar *)(facs[i]->name));
}
else
{
if(autocoalesce)
{
if(facs[i]->vec_root!=facs[i]) continue;
tmp2=makename_chain(facs[i]);
s=(char *)malloc_2(strlen(tmp2)+4);
strcpy(s,"[] ");
strcpy(s+3, tmp2);
free_2(tmp2);
}
else
{
s=(char *)malloc_2(strlen(facs[i]->name)+4);
strcpy(s,"[] ");
strcpy(s+3, facs[i]->name);
}
row=gtk_clist_append(cl,(gchar **)&s);
pixlen=gdk_string_measure(signalfont,(gchar *)s);
free_2(s);
}
maxpixlen=(pixlen>maxpixlen)?pixlen:maxpixlen;
gtk_clist_set_row_data(cl, row,facs[i]);
num_rows++;
if(num_rows==WAVE_MAX_CLIST_LENGTH) break;
}
}
gtk_clist_set_column_width(GTK_CLIST(clist),0,maxpixlen?maxpixlen:1);
gtk_clist_thaw(cl);
gtk_progress_set_value (GTK_PROGRESS (pdata->pbar), 0.0);
pdata->oldvalue = -1.0;
gtk_grab_remove(widget);
is_searching_running=0;
if(do_warning)
if(num_rows>=WAVE_MAX_CLIST_LENGTH)
{
char buf[256];
sprintf(buf, "Limiting results to first %d entries.", num_rows);
simplereqbox("Regex Search Warning",300,buf,"OK", NULL, NULL);
}
}
/*
* Función borrarDireccionDialogo()
*/
void borrarDireccionDialogo (void)
{
GtkWidget *window;
GtkWidget *label;
GtkWidget *nombre;
GtkWidget *box;
GtkWidget *botonAceptar;
GtkWidget *botonCancelar;
GtkWidget *hbox1;
DatosDir *conector;
conector=malloc(sizeof(DatosDir));
if (NULL == conector) {
perror("malloc:");
return;
}
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize (GTK_WIDGET (window), 300, 125);
gtk_window_set_policy(GTK_WINDOW (window), TRUE, TRUE, FALSE);
gtk_window_set_title (GTK_WINDOW (window), "Eliminar dirección");
gtk_container_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_uposition( window, 300, 300 );
box=gtk_vbox_new(FALSE,5);
label=gtk_label_new("Introduzca el nombre a borrar");
gtk_misc_set_alignment (GTK_MISC(label), 0, .5);
gtk_box_pack_start(GTK_BOX(box),label,FALSE,FALSE,0);
nombre=gtk_entry_new();
gtk_box_pack_start(GTK_BOX(box),nombre,FALSE,FALSE,0);
hbox1=gtk_hbox_new(FALSE,40);
/*
* OK y Cancel
*/
botonAceptar = gtk_button_new_with_label ("Aceptar");
botonCancelar = gtk_button_new_with_label ("Cancelar");
conector->window=window;
conector->nombre=nombre;
conector->operacion=BORRAR;
conector->direccion=NULL;
conector->telefono=NULL;
gtk_container_add (GTK_CONTAINER (hbox1), botonAceptar);
gtk_container_add (GTK_CONTAINER (hbox1), botonCancelar);
gtk_signal_connect(GTK_OBJECT(botonAceptar), "clicked",
GTK_SIGNAL_FUNC(AceptarDireccionDialogo),
(gpointer)conector);
gtk_signal_connect(GTK_OBJECT(botonCancelar), "clicked",
GTK_SIGNAL_FUNC(cancelarDireccionDialogo),
(gpointer)conector);
gtk_widget_show (botonAceptar);
gtk_widget_show (botonCancelar);
gtk_box_pack_start(GTK_BOX(box),hbox1,FALSE,FALSE,15);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_grab_add(window);
gtk_widget_show_all(window);
}
extern "C" void Sys_FPrintf_VA( int level, const char *text, va_list args ) {
char buf[BUFFER_SIZE];
buf[0] = 0;
vsnprintf( buf, BUFFER_SIZE, text, args );
buf[BUFFER_SIZE - 1] = 0;
const unsigned int length = strlen( buf );
if ( g_qeglobals.hLogFile ) {
#ifdef _WIN32
_write( g_qeglobals.hLogFile, buf, length );
_commit( g_qeglobals.hLogFile );
#endif
#if defined ( __linux__ ) || defined ( __APPLE__ )
write( g_qeglobals.hLogFile, buf, length );
#endif
}
if ( level != SYS_NOCON ) {
// TTimo: FIXME: killed the console to avoid GDI leak fuckup
if ( g_qeglobals_gui.d_edit != NULL ) {
GtkTextBuffer* buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW( g_qeglobals_gui.d_edit ) );
GtkTextIter iter;
gtk_text_buffer_get_end_iter( buffer, &iter );
static GtkTextMark* end = gtk_text_buffer_create_mark( buffer, "end", &iter, FALSE );
const GdkColor yellow = { 0, 0xb0ff, 0xb0ff, 0x0000 };
const GdkColor red = { 0, 0xffff, 0x0000, 0x0000 };
const GdkColor black = { 0, 0x0000, 0x0000, 0x0000 };
static GtkTextTag* error_tag = gtk_text_buffer_create_tag( buffer, "red_foreground", "foreground-gdk", &red, NULL );
static GtkTextTag* warning_tag = gtk_text_buffer_create_tag( buffer, "yellow_foreground", "foreground-gdk", &yellow, NULL );
static GtkTextTag* standard_tag = gtk_text_buffer_create_tag( buffer, "black_foreground", "foreground-gdk", &black, NULL );
GtkTextTag* tag;
switch ( level )
{
case SYS_WRN:
tag = warning_tag;
break;
case SYS_ERR:
tag = error_tag;
break;
case SYS_STD:
case SYS_VRB:
default:
tag = standard_tag;
break;
}
gtk_text_buffer_insert_with_tags( buffer, &iter, buf, length, tag, NULL );
gtk_text_view_scroll_mark_onscreen( GTK_TEXT_VIEW( g_qeglobals_gui.d_edit ), end );
// update console widget immediatly if we're doing something time-consuming
if ( !g_bScreenUpdates && GTK_WIDGET_REALIZED( g_qeglobals_gui.d_edit ) ) {
gtk_grab_add( g_qeglobals_gui.d_edit );
while ( gtk_events_pending() )
gtk_main_iteration();
gtk_grab_remove( g_qeglobals_gui.d_edit );
}
}
}
}
void show_header (void)
{
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *label1, *label2,*label3,*label4,*label5,*label6,*label7,*label8,*label9,*label10,
*label11;
char *ndata;
int n1=2, n2=0, length=0;
if(floaded==FALSE) {return;}
hdata=(char*)malloc(1024 * sizeof(char));
ndata=(char*)malloc(32 * sizeof(char));
window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_object_set_data (GTK_OBJECT (window1), "window1", window1);
gtk_window_set_title (GTK_WINDOW (window1), ("Data of ATS File "));
gtk_window_set_policy (GTK_WINDOW (window1), FALSE, TRUE, TRUE);
gtk_window_set_position(GTK_WINDOW(window1),GTK_WIN_POS_CENTER);
gtk_widget_show(window1);
gtk_signal_connect (GTK_OBJECT (window1), "destroy",
GTK_SIGNAL_FUNC (hclose),NULL);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (window1), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (window1), vbox1);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox2);
gtk_object_set_data_full (GTK_OBJECT (window1), "vbox2", vbox2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0);
//////////////////////////////////////////////////////////////
*hdata=0;
strcat(hdata,"FILENAME: ");
strcat(hdata,ats_tittle);
label1 = gtk_label_new (hdata);
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (window1), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_box_pack_start (GTK_BOX (vbox2), label1, TRUE, TRUE, 10);
gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT);
create_hsep(vbox2);
//////////////////////////////////////////////////////////////
if(FILE_HAS_PHASE) {
n1+=1;
}
if(FILE_HAS_NOISE) {
n2+=1;
}
length = sizeof(ATS_HEADER) +
((int)atshed->par * (int)atshed->fra * sizeof(double) * n1) +
(sizeof(double) * (int)atshed->fra) +
(ATSA_CRITICAL_BANDS * (int)atshed->fra * sizeof(double) * n2);
*hdata=0;
*ndata=0;
strcat(hdata,"FILE SIZE: ");
sprintf(ndata,"%d",length);
strcat(hdata,ndata);
strcat(hdata," bytes");
label2 = gtk_label_new (hdata);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
gtk_widget_ref (label2);
gtk_object_set_data_full (GTK_OBJECT (window1), "label2", label2,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label2);
gtk_box_pack_start (GTK_BOX (vbox2), label2, TRUE, TRUE, 10);
create_hsep(vbox2);
///////////////////////////////////////////////////////////////////
*hdata=0;
*ndata=0;
strcat(hdata,"SAMPLING RATE: ");
sprintf(ndata,"%d",(int)atshed->sr);
strcat(hdata,ndata);
strcat(hdata," Hz.");
label3 = gtk_label_new (hdata);
gtk_widget_ref (label3);
gtk_object_set_data_full (GTK_OBJECT (window1), "label3", label3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label3);
gtk_box_pack_start (GTK_BOX (vbox2), label3, TRUE, TRUE, 10);
gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT);
create_hsep(vbox2);
//////////////////////////////////////////////////////////////////
*hdata=0;
*ndata=0;
strcat(hdata,"FRAME SIZE: ");
sprintf(ndata,"%d (%4.3f secs.)",(int)atshed->fs,atshed->fs / atshed->sr );
strcat(hdata,ndata);
label4 = gtk_label_new (hdata);
gtk_widget_ref (label4);
gtk_object_set_data_full (GTK_OBJECT (window1), "label4", label4,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label4);
gtk_box_pack_start (GTK_BOX (vbox2), label4, TRUE, TRUE, 10);
gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT);
create_hsep(vbox2);
//////////////////////////////////////////////////////////////////
*hdata=0;
*ndata=0;
strcat(hdata,"WINDOW SIZE: ");
sprintf(ndata,"%d",(int)atshed->ws);
strcat(hdata,ndata);
label5 = gtk_label_new (hdata);
gtk_widget_ref (label5);
gtk_object_set_data_full (GTK_OBJECT (window1), "label5", label5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label5);
gtk_box_pack_start (GTK_BOX (vbox2), label5, TRUE, TRUE, 10);
gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT);
create_hsep(vbox2);
//////////////////////////////////////////////////////////////////
*hdata=0;
*ndata=0;
strcat(hdata,"PARTIALS PER FRAME: ");
sprintf(ndata,"%d",(int)atshed->par);
strcat(hdata,ndata);
label6 = gtk_label_new (hdata);
gtk_widget_ref (label6);
gtk_object_set_data_full (GTK_OBJECT (window1), "label6", label6,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label6);
gtk_box_pack_start (GTK_BOX (vbox2), label6, TRUE, TRUE, 10);
gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT);
create_hsep(vbox2);
//////////////////////////////////////////////////////////////////
*hdata=0;
*ndata=0;
strcat(hdata,"FRAMES: ");
sprintf(ndata,"%d",(int)atshed->fra);
strcat(hdata,ndata);
label7 = gtk_label_new (hdata);
gtk_widget_ref (label7);
gtk_object_set_data_full (GTK_OBJECT (window1), "label7", label7,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label7);
gtk_box_pack_start (GTK_BOX (vbox2), label7, TRUE, TRUE, 10);
gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT);
create_hsep(vbox2);
//////////////////////////////////////////////////////////////////
*hdata=0;
*ndata=0;
strcat(hdata,"DURATION: ");
sprintf(ndata,"%7.3f",(float)atshed->dur);
strcat(hdata,ndata);
strcat(hdata," secs.");
label8 = gtk_label_new (hdata);
gtk_widget_ref (label8);
gtk_object_set_data_full (GTK_OBJECT (window1), "label8", label8,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label8);
gtk_box_pack_start (GTK_BOX (vbox2), label8, TRUE, TRUE, 10);
gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT);
create_hsep(vbox2);
//////////////////////////////////////////////////////////////////
*hdata=0;
*ndata=0;
strcat(hdata,"MAX. AMP.: ");
sprintf(ndata,"%5.3f",(float)atshed->ma);
strcat(hdata,ndata);
label9 = gtk_label_new (hdata);
gtk_widget_ref (label9);
gtk_object_set_data_full (GTK_OBJECT (window1), "label9", label9,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label9);
gtk_box_pack_start (GTK_BOX (vbox2), label9, TRUE, TRUE, 10);
gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT);
create_hsep(vbox2);
//////////////////////////////////////////////////////////////////
*hdata=0;
*ndata=0;
strcat(hdata,"MAX. FREQ.: ");
sprintf(ndata,"%7.2f",(float)atshed->mf);
strcat(hdata,ndata);
strcat(hdata," Hz.");
label10 = gtk_label_new (hdata);
gtk_widget_ref (label10);
gtk_object_set_data_full (GTK_OBJECT (window1), "label10", label10,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label10);
gtk_box_pack_start (GTK_BOX (vbox2), label10, TRUE, TRUE, 10);
gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT);
create_hsep(vbox2);
//////////////////////////////////////////////////////////////////
*hdata=0;
*ndata=0;
strcat(hdata,"TYPE: ");
sprintf(ndata,"%d",(int)atshed->typ);
strcat(hdata,ndata);
switch ((int)atshed->typ) {
case 1:
strcat(hdata," (Only Amplitude and Frequency data on file) ");
break;
case 2:
strcat(hdata," (Amplitude, Frequency, and Phase data on file) ");
break;
case 3:
strcat(hdata," (Amplitude, Frequency, and Residual Analysis data on file) ");
break;
case 4:
strcat(hdata," (All Amplitude, Frequency, Phase, and Residual Analysis data on file) ");
break;
}
label11 = gtk_label_new (hdata);
gtk_widget_ref (label11);
gtk_object_set_data_full (GTK_OBJECT (window1), "label11", label11,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label11);
gtk_box_pack_start (GTK_BOX (vbox2), label11, TRUE, TRUE, 10);
gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_LEFT);
gtk_grab_add (window1);
free(ndata);
return;
}
static gboolean
gtk_scale_popup (GtkWidget *widget,
GdkEvent *event,
guint32 time)
{
GtkScaleButton *button;
GtkScaleButtonPrivate *priv;
GtkAdjustment *adj;
gint x, y, m, dx, dy, sx, sy, startoff;
gdouble v;
GdkDisplay *display;
GdkScreen *screen;
button = GTK_SCALE_BUTTON (widget);
priv = button->priv;
adj = priv->adjustment;
display = gtk_widget_get_display (widget);
screen = gtk_widget_get_screen (widget);
/* position roughly */
gtk_window_set_screen (GTK_WINDOW (priv->dock), screen);
gdk_window_get_origin (widget->window, &x, &y);
x += widget->allocation.x;
y += widget->allocation.y;
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
gtk_window_move (GTK_WINDOW (priv->dock), x, y - (SCALE_SIZE / 2));
else
gtk_window_move (GTK_WINDOW (priv->dock), x - (SCALE_SIZE / 2), y);
gtk_widget_show_all (priv->dock);
gdk_window_get_origin (priv->dock->window, &dx, &dy);
dx += priv->dock->allocation.x;
dy += priv->dock->allocation.y;
gdk_window_get_origin (priv->scale->window, &sx, &sy);
sx += priv->scale->allocation.x;
sy += priv->scale->allocation.y;
priv->timeout = TRUE;
/* position (needs widget to be shown already) */
v = gtk_scale_button_get_value (button) / (adj->upper - adj->lower);
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
{
startoff = sy - dy;
x += (widget->allocation.width - priv->dock->allocation.width) / 2;
y -= startoff;
y -= GTK_RANGE (priv->scale)->min_slider_size / 2;
m = priv->scale->allocation.height -
GTK_RANGE (priv->scale)->min_slider_size;
y -= m * (1.0 - v);
}
else
{
startoff = sx - dx;
x -= startoff;
y += (widget->allocation.height - priv->dock->allocation.height) / 2;
x -= GTK_RANGE (priv->scale)->min_slider_size / 2;
m = priv->scale->allocation.width -
GTK_RANGE (priv->scale)->min_slider_size;
x -= m * v;
}
/* Make sure the dock stays inside the monitor */
if (event->type == GDK_BUTTON_PRESS)
{
int monitor;
GdkEventButton *button_event = (GdkEventButton *) event;
GdkRectangle rect;
GtkWidget *d;
d = GTK_WIDGET (priv->dock);
monitor = gdk_screen_get_monitor_at_point (screen,
button_event->x_root,
button_event->y_root);
gdk_screen_get_monitor_geometry (screen, monitor, &rect);
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
y += button_event->y;
else
x += button_event->x;
if (y < rect.y)
y = rect.y;
else if (y + d->allocation.height > rect.height + rect.y)
y = rect.y + rect.height - d->allocation.height;
if (x < rect.x)
x = rect.x;
else if (x + d->allocation.width > rect.width + rect.x)
x = rect.x + rect.width - d->allocation.width;
}
gtk_window_move (GTK_WINDOW (priv->dock), x, y);
if (event->type == GDK_BUTTON_PRESS)
GTK_WIDGET_CLASS (gtk_scale_button_parent_class)->button_press_event (widget, (GdkEventButton *) event);
/* grab focus */
gtk_grab_add (priv->dock);
if (gdk_pointer_grab (priv->dock->window, TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK, NULL, NULL, time)
!= GDK_GRAB_SUCCESS)
{
gtk_grab_remove (priv->dock);
gtk_widget_hide (priv->dock);
return FALSE;
}
if (gdk_keyboard_grab (priv->dock->window, TRUE, time) != GDK_GRAB_SUCCESS)
{
gdk_display_pointer_ungrab (display, time);
gtk_grab_remove (priv->dock);
gtk_widget_hide (priv->dock);
return FALSE;
}
gtk_widget_grab_focus (priv->dock);
if (event->type == GDK_BUTTON_PRESS)
{
GdkEventButton *e;
GdkEventButton *button_event = (GdkEventButton *) event;
/* forward event to the slider */
e = (GdkEventButton *) gdk_event_copy ((GdkEvent *) event);
e->window = priv->scale->window;
/* position: the X position isn't relevant, halfway will work just fine.
* The vertical position should be *exactly* in the middle of the slider
* of the scale; if we don't do that correctly, it'll move from its current
* position, which means a position change on-click, which is bad.
*/
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
{
e->x = priv->scale->allocation.width / 2;
m = priv->scale->allocation.height -
GTK_RANGE (priv->scale)->min_slider_size;
e->y = ((1.0 - v) * m) + GTK_RANGE (priv->scale)->min_slider_size / 2;
}
else
{
e->y = priv->scale->allocation.height / 2;
m = priv->scale->allocation.width -
GTK_RANGE (priv->scale)->min_slider_size;
e->x = (v * m) + GTK_RANGE (priv->scale)->min_slider_size / 2;
}
gtk_widget_event (priv->scale, (GdkEvent *) e);
e->window = button_event->window;
gdk_event_free ((GdkEvent *) e);
}
gtk_widget_grab_focus (priv->scale);
priv->pop_time = time;
return TRUE;
}
bool wxPopupTransientWindow::Show( bool show )
{
#ifdef __WXGTK__
if (!show)
{
#ifdef __WXGTK3__
GdkDisplay* display = gtk_widget_get_display(m_widget);
#ifdef __WXGTK4__
gdk_seat_ungrab(gdk_display_get_default_seat(display));
#else
wxGCC_WARNING_SUPPRESS(deprecated-declarations)
GdkDeviceManager* manager = gdk_display_get_device_manager(display);
GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
gdk_device_ungrab(device, unsigned(GDK_CURRENT_TIME));
wxGCC_WARNING_RESTORE()
#endif
#else
gdk_pointer_ungrab( (guint32)GDK_CURRENT_TIME );
#endif
gtk_grab_remove( m_widget );
}
#endif
#ifdef __WXX11__
if (!show)
{
XUngrabPointer( wxGlobalDisplay(), CurrentTime );
}
#endif
#if defined( __WXMSW__ ) || defined( __WXMAC__)
if (!show && m_child && m_child->HasCapture())
{
m_child->ReleaseMouse();
}
#endif
bool ret = wxPopupWindow::Show( show );
#ifdef __WXGTK__
if (show)
{
gtk_grab_add( m_widget );
GdkWindow* window = gtk_widget_get_window(m_widget);
#ifdef __WXGTK4__
GdkDisplay* display = gdk_window_get_display(window);
GdkSeat* seat = gdk_display_get_default_seat(display);
gdk_seat_grab(seat, window, GDK_SEAT_CAPABILITY_POINTER, false, NULL, NULL, NULL, 0);
#else
const GdkEventMask mask = GdkEventMask(
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_HINT_MASK |
GDK_POINTER_MOTION_MASK);
#ifdef __WXGTK3__
GdkDisplay* display = gdk_window_get_display(window);
wxGCC_WARNING_SUPPRESS(deprecated-declarations)
GdkDeviceManager* manager = gdk_display_get_device_manager(display);
GdkDevice* device = gdk_device_manager_get_client_pointer(manager);
gdk_device_grab(device, window,
GDK_OWNERSHIP_NONE, true, mask, NULL, unsigned(GDK_CURRENT_TIME));
wxGCC_WARNING_RESTORE()
#else
gdk_pointer_grab( window, true,
mask,
NULL,
NULL,
(guint32)GDK_CURRENT_TIME );
#endif
#endif // !__WXGTK4__
}
#endif
#ifdef __WXX11__
if (show)
{
Window xwindow = (Window) m_clientWindow;
/* int res =*/ XGrabPointer(wxGlobalDisplay(), xwindow,
True,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
GrabModeAsync,
GrabModeAsync,
None,
None,
CurrentTime );
}
#endif
#if defined( __WXMSW__ ) || defined( __WXMAC__)
if (show && m_child)
{
// Assume that the mouse is outside the popup to begin with
m_child->CaptureMouse();
}
#endif
return ret;
}
/*----------------------------------------------------------------------------------------------------------------------*/
void MakeAscii2d(GtkWidget *Win,gpointer Data)
{
gchar OutFName[MAX_FNAME_LENGTH+5],Str[150];
const gchar *BitType;
FILE *Fp;
gshort XSize,YSize;
guint16 *Data16;
guint32 *Data32,DMax;
gint X,Y,WSize;
gboolean Error;
GtkWidget *W,*Label,*But;
if (!Ascii2d->Ready) { Attention(0,"Error: No file selected!"); return; }
strcpy(OutFName,gtk_entry_get_text(GTK_ENTRY(Ascii2d->OutEntry)));
BitType=gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(Ascii2d->BitCombo)->entry));
if ( !(Fp=fopen(Ascii2d->InFName,"r")))
{ sprintf(Str,"Could not open %s",Ascii2d->InFName); Attention(0,Str); return; }
fread(&XSize,sizeof(gshort),1,Fp); fread(&YSize,sizeof(gshort),1,Fp);
if (BitType[0]=='S') { WSize=1; Data16=g_new(guint16,XSize*YSize); InitMat16(XSize,YSize,Data16); }
else { WSize=2; Data32=g_new(guint32,XSize*YSize); InitMat32(XSize,YSize,Data32); }
Readz2d(WSize,XSize,YSize,Fp,Data16,Data32,&Error);
fclose(Fp);
if (Error) { sprintf(Str,"Error reading %s",Ascii2d->InFName); Attention(0,Str); return; }
if ( !(Fp=fopen(OutFName,"w"))) { sprintf(Str,"Could not open %s",OutFName); Attention(0,Str); return; }
fprintf(Fp,"#Ascii file suitable for gnuplot: splot \"%s\"\n",OutFName);
if (WSize==1)
{
for (X=0,DMax=0;X<XSize;++X)
{
for (Y=0;Y<YSize;++Y)
{
fprintf(Fp,"%4d %6d %d\n",X,Y,Data16[X+XSize*Y]);
if ((X>0) && (Y>0)) DMax=MAX(DMax,(guint32)Data16[X+XSize*Y]);
}
fprintf(Fp,"\n");
}
g_free(Data16);
}
else
{
for (X=0,DMax=0;X<XSize;++X)
{
for (Y=0;Y<YSize;++Y)
{
fprintf(Fp,"%4d %6d %d\n",X,Y,Data32[X+XSize*Y]);
if ((X>0) && (Y>0)) DMax=MAX(DMax,Data32[X+XSize*Y]);
}
fprintf(Fp,"\n");
}
g_free(Data32);
}
fclose(Fp);
W=gtk_dialog_new(); gtk_grab_add(W); gtk_window_set_title(GTK_WINDOW(W),"Finished");
gtk_widget_set_uposition(GTK_WIDGET(W),350,350); //gtk_widget_set_usize(GTK_WIDGET(W),300,100);
gtk_signal_connect_object(GTK_OBJECT(W),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),GTK_OBJECT(W));
sprintf(Str,"File ./%s written",OutFName);
Label=gtk_label_new(Str); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(W)->vbox),Label,TRUE,FALSE,5);
sprintf(Str,"For gnuplot: splot [0:%d] [0:%d] [1:%d] \"%s\"",XSize,YSize,DMax,OutFName);
Label=gtk_label_new(Str); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(W)->vbox),Label,TRUE,FALSE,5);
Fp=fopen("work.gnu","w");
fprintf(Fp,"splot [0:%d] [0:%d] [1:%d] \"%s\"",XSize,YSize,DMax,OutFName);
fclose(Fp);
But=gtk_button_new_with_label("Dismiss");
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(W)->action_area),But,TRUE,FALSE,0);
gtk_signal_connect_object(GTK_OBJECT(But),"clicked",GTK_SIGNAL_FUNC(gtk_widget_destroy),GTK_OBJECT(W));
gtk_widget_show_all(W);
}
void
gstyle_eyedropper_set_source_event (GstyleEyedropper *self,
GdkEvent *event)
{
GtkWidget *source;
GtkStyleContext *context;
GtkWidget *box;
GtkWidget *swatch;
GdkGrabStatus status;
gint x_root, y_root;
gint x, y;
g_return_if_fail (GSTYLE_IS_EYEDROPPER (self));
g_return_if_fail (event != NULL);
self->seat = g_object_ref (gdk_event_get_seat (event));
source = gtk_get_event_widget (event);
self->screen = gdk_event_get_screen (event);
g_signal_connect_swapped (self->screen,
"size-changed",
G_CALLBACK (gstyle_eyedropper_screen_size_changed_cb),
self);
self->window = g_object_ref_sink (gtk_window_new (GTK_WINDOW_POPUP));
gtk_window_set_screen (GTK_WINDOW (self->window),self->screen);
gtk_widget_set_name (self->window, "gstyleeyedropper");
context = gtk_widget_get_style_context (self->window);
self->default_provider = gstyle_css_provider_init_default (gtk_style_context_get_screen (context));
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (self->window), box);
self->zoom_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (self->zoom_area, ZOOM_AREA_WIDTH, ZOOM_AREA_HEIGHT);
gtk_container_add (GTK_CONTAINER (box), self->zoom_area);
swatch = g_object_new (GSTYLE_TYPE_COLOR_WIDGET,
"fallback-name-kind", GSTYLE_COLOR_KIND_RGB_HEX6,
"fallback-name-visible", TRUE,
"color", self->color,
NULL);
gtk_container_add (GTK_CONTAINER (box), swatch);
g_signal_connect_object (self->zoom_area,
"draw",
G_CALLBACK (gstyle_eyedropper_zoom_area_draw_cb),
self,
G_CONNECT_SWAPPED);
self->screen_width = gdk_screen_get_width (self->screen);
self->screen_height = gdk_screen_get_height (self->screen);
gstyle_eyedropper_event_get_root_coords (self, event, &x_root, &y_root);
gstyle_eyedropper_calculate_window_position (self, GTK_WINDOW (self->window), x_root, y_root, &x, &y);
gtk_window_move (GTK_WINDOW (self->window), x, y);
gtk_widget_show_all (self->window);
gtk_widget_add_events (self->window,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
self->cursor = gdk_cursor_new_from_name (gdk_screen_get_display (self->screen), "cell");
gtk_grab_add (self->window);
status = gdk_seat_grab (self->seat,
gtk_widget_get_window (source),
GDK_SEAT_CAPABILITY_ALL,
FALSE,
self->cursor,
event,
NULL, NULL);
if (status != GDK_GRAB_SUCCESS)
{
g_warning ("grab failed status:%i\n", status);
return;
}
self->motion_notify_handler_id =
g_signal_connect_swapped (self->window, "motion-notify-event",
G_CALLBACK (gstyle_eyedropper_pointer_motion_notify_cb),
self);
self->pointer_pressed_handler_id =
g_signal_connect_swapped (self->window,
"button-press-event",
G_CALLBACK (gstyle_eyedropper_pointer_pressed_cb),
self);
self->pointer_wheel_handler_id =
g_signal_connect_swapped (self->window,
"scroll-event",
G_CALLBACK (gstyle_eyedropper_pointer_wheel_cb),
self);
self->key_handler_id =
g_signal_connect_swapped (self->window,
"key-press-event",
G_CALLBACK (gstyle_eyedropper_key_pressed_cb),
self);
self->grab_broken_handler_id =
g_signal_connect_swapped (self->window,
"grab-broken-event",
G_CALLBACK (gstyle_eyedropper_grab_broken_cb),
self);
}
/* Pops up a menu of actions to perform on dropped files */
GdkDragAction
nautilus_drag_drop_action_ask (GtkWidget *widget,
GdkDragAction actions)
{
GtkWidget *menu;
GtkWidget *menu_item;
DropActionMenuData damd;
/* Create the menu and set the sensitivity of the items based on the
* allowed actions.
*/
menu = gtk_menu_new ();
gtk_menu_set_screen (GTK_MENU (menu), gtk_widget_get_screen (widget));
append_drop_action_menu_item (menu, _("_Move Here"),
GDK_ACTION_MOVE,
(actions & GDK_ACTION_MOVE) != 0,
&damd);
append_drop_action_menu_item (menu, _("_Copy Here"),
GDK_ACTION_COPY,
(actions & GDK_ACTION_COPY) != 0,
&damd);
append_drop_action_menu_item (menu, _("_Link Here"),
GDK_ACTION_LINK,
(actions & GDK_ACTION_LINK) != 0,
&damd);
append_drop_action_menu_item (menu, _("Set as _Background"),
NAUTILUS_DND_ACTION_SET_AS_BACKGROUND,
(actions & NAUTILUS_DND_ACTION_SET_AS_BACKGROUND) != 0,
&damd);
eel_gtk_menu_append_separator (GTK_MENU (menu));
menu_item = gtk_menu_item_new_with_mnemonic (_("Cancel"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
gtk_widget_show (menu_item);
damd.chosen = 0;
damd.loop = g_main_loop_new (NULL, FALSE);
g_signal_connect (menu, "deactivate",
G_CALLBACK (menu_deactivate_callback),
&damd);
gtk_grab_add (menu);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
NULL, NULL, 0, GDK_CURRENT_TIME);
g_main_loop_run (damd.loop);
gtk_grab_remove (menu);
g_main_loop_unref (damd.loop);
gtk_object_sink (GTK_OBJECT (menu));
return damd.chosen;
}
/* Make the user pick a DiscDB genre on submit*/
static void GetDiscDBGenre(GripInfo *ginfo)
{
GtkWidget *dialog;
GtkWidget *label;
GtkWidget *submit_button;
GtkWidget *cancel_button;
GtkWidget *hbox;
GtkWidget *genre_combo;
GtkWidget *item;
int genre;
dialog=gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog),_("Genre selection"));
gtk_container_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox),5);
label=gtk_label_new(_("Submission requires a genre other than 'unknown'\n"
"Please select a DiscDB genre below"));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),label,TRUE,TRUE,0);
gtk_widget_show(label);
genre_combo=gtk_combo_new();
gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(genre_combo)->entry),FALSE);
hbox=gtk_hbox_new(FALSE,3);
label=gtk_label_new(_("DiscDB genre"));
gtk_box_pack_start(GTK_BOX(hbox),label,FALSE,FALSE,0);
gtk_widget_show(label);
for(genre=0;genre<12;genre++) {
item=gtk_list_item_new_with_label(DiscDBGenre(genre));
gtk_object_set_user_data(GTK_OBJECT(item),
(gpointer)genre);
gtk_signal_connect(GTK_OBJECT(item), "select",
GTK_SIGNAL_FUNC(DiscDBGenreChanged),(gpointer)ginfo);
gtk_container_add(GTK_CONTAINER(GTK_COMBO(genre_combo)->list),item);
gtk_widget_show(item);
}
gtk_box_pack_start(GTK_BOX(hbox),genre_combo,TRUE,TRUE,0);
gtk_widget_show(genre_combo);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),hbox,TRUE,TRUE,0);
gtk_widget_show(hbox);
submit_button=gtk_button_new_with_label(_("Submit"));
gtk_signal_connect(GTK_OBJECT(submit_button),"clicked",
(gpointer)SubmitEntryCB,(gpointer)ginfo);
gtk_signal_connect_object(GTK_OBJECT(submit_button),"clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(dialog));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),submit_button,
TRUE,TRUE,0);
gtk_widget_show(submit_button);
cancel_button=gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect_object(GTK_OBJECT(cancel_button),"clicked",
GTK_SIGNAL_FUNC(gtk_widget_destroy),
GTK_OBJECT(dialog));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),cancel_button,
TRUE,TRUE,0);
gtk_widget_show(cancel_button);
gtk_widget_show(dialog);
gtk_grab_add(dialog);
}
void DoConfigDialog(){
GtkWidget *dlg, *hbox, *vbox, *vbox2, *button, *table, *frame;
GtkWidget *lw3slider, *lw3label, *lw2slider, *lw2label, *zlist, *menu, *item;
GtkWidget *aa2check, *aa3check, *depthcheck, *linescheck, *polyscheck;
GtkWidget *transslider, *translabel, *clipslider, *cliplabel;
GtkWidget *show2check, *show3check, *portalcheck;
int loop = 1, ret = IDCANCEL;
GtkObject *adj;
dlg = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW( dlg ), _( "Portal Viewer Configuration" ) );
gtk_signal_connect( GTK_OBJECT( dlg ), "delete_event",
GTK_SIGNAL_FUNC( dialog_delete_callback ), NULL );
gtk_signal_connect( GTK_OBJECT( dlg ), "destroy",
GTK_SIGNAL_FUNC( gtk_widget_destroy ), NULL );
g_object_set_data( G_OBJECT( dlg ), "loop", &loop );
g_object_set_data( G_OBJECT( dlg ), "ret", &ret );
vbox = gtk_vbox_new( FALSE, 5 );
gtk_widget_show( vbox );
gtk_container_add( GTK_CONTAINER( dlg ), vbox );
gtk_container_set_border_width( GTK_CONTAINER( vbox ), 5 );
frame = gtk_frame_new( _( "3D View" ) );
gtk_widget_show( frame );
gtk_box_pack_start( GTK_BOX( vbox ), frame, TRUE, TRUE, 0 );
vbox2 = gtk_vbox_new( FALSE, 5 );
gtk_widget_show( vbox2 );
gtk_container_add( GTK_CONTAINER( frame ), vbox2 );
gtk_container_set_border_width( GTK_CONTAINER( vbox2 ), 5 );
hbox = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox );
gtk_box_pack_start( GTK_BOX( vbox2 ), hbox, TRUE, TRUE, 0 );
adj = gtk_adjustment_new( portals.width_3d, 2, 40, 1, 1, 1 );
lw3slider = gtk_hscale_new( GTK_ADJUSTMENT( adj ) );
gtk_widget_show( lw3slider );
gtk_box_pack_start( GTK_BOX( hbox ), lw3slider, TRUE, TRUE, 0 );
gtk_scale_set_draw_value( GTK_SCALE( lw3slider ), FALSE );
lw3label = gtk_label_new( "" );
gtk_widget_show( lw3label );
gtk_box_pack_start( GTK_BOX( hbox ), lw3label, FALSE, TRUE, 0 );
gtk_signal_connect( adj, "value_changed", GTK_SIGNAL_FUNC( OnScroll3d ), lw3label );
table = gtk_table_new( 2, 4, FALSE );
gtk_widget_show( table );
gtk_box_pack_start( GTK_BOX( vbox2 ), table, TRUE, TRUE, 0 );
gtk_table_set_row_spacings( GTK_TABLE( table ), 5 );
gtk_table_set_col_spacings( GTK_TABLE( table ), 5 );
button = gtk_button_new_with_label( _( "Color" ) );
gtk_widget_show( button );
gtk_table_attach( GTK_TABLE( table ), button, 0, 1, 0, 1,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked", GTK_SIGNAL_FUNC( OnColor3d ), NULL );
button = gtk_button_new_with_label( _( "Depth Color" ) );
gtk_widget_show( button );
gtk_table_attach( GTK_TABLE( table ), button, 0, 1, 1, 2,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked", GTK_SIGNAL_FUNC( OnColorFog ), NULL );
aa3check = gtk_check_button_new_with_label( "Anti-Alias (May not work on some video cards)" );
gtk_widget_show( aa3check );
gtk_table_attach( GTK_TABLE( table ), aa3check, 1, 4, 0, 1,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( aa3check ), "toggled", GTK_SIGNAL_FUNC( OnAntiAlias3d ), NULL );
depthcheck = gtk_check_button_new_with_label( _( "Depth Cue" ) );
gtk_widget_show( depthcheck );
gtk_table_attach( GTK_TABLE( table ), depthcheck, 1, 2, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( depthcheck ), "toggled", GTK_SIGNAL_FUNC( OnFog ), NULL );
linescheck = gtk_check_button_new_with_label( _( "Lines" ) );
gtk_widget_show( linescheck );
gtk_table_attach( GTK_TABLE( table ), linescheck, 2, 3, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( linescheck ), "toggled", GTK_SIGNAL_FUNC( OnLines ), NULL );
polyscheck = gtk_check_button_new_with_label( _( "Polygons" ) );
gtk_widget_show( polyscheck );
gtk_table_attach( GTK_TABLE( table ), polyscheck, 3, 4, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( polyscheck ), "toggled", GTK_SIGNAL_FUNC( OnPoly ), NULL );
zlist = gtk_option_menu_new();
gtk_widget_show( zlist );
gtk_box_pack_start( GTK_BOX( vbox2 ), zlist, TRUE, FALSE, 0 );
menu = gtk_menu_new();
gtk_widget_show( menu );
gtk_option_menu_set_menu( GTK_OPTION_MENU( zlist ), menu );
item = gtk_menu_item_new_with_label( _( "Z-Buffer Test and Write (recommended for solid or no polygons)" ) );
gtk_widget_show( item );
gtk_signal_connect( GTK_OBJECT( item ), "activate",
GTK_SIGNAL_FUNC( OnSelchangeZbuffer ), GINT_TO_POINTER( 0 ) );
gtk_menu_append( GTK_MENU( menu ), item );
item = gtk_menu_item_new_with_label( _( "Z-Buffer Test Only (recommended for transparent polygons)" ) );
gtk_widget_show( item );
gtk_signal_connect( GTK_OBJECT( item ), "activate",
GTK_SIGNAL_FUNC( OnSelchangeZbuffer ), GINT_TO_POINTER( 1 ) );
gtk_menu_append( GTK_MENU( menu ), item );
item = gtk_menu_item_new_with_label( _( "Z-Buffer Off" ) );
gtk_widget_show( item );
gtk_signal_connect( GTK_OBJECT( item ), "activate",
GTK_SIGNAL_FUNC( OnSelchangeZbuffer ), GINT_TO_POINTER( 2 ) );
gtk_menu_append( GTK_MENU( menu ), item );
table = gtk_table_new( 2, 2, FALSE );
gtk_widget_show( table );
gtk_box_pack_start( GTK_BOX( vbox2 ), table, TRUE, TRUE, 0 );
gtk_table_set_row_spacings( GTK_TABLE( table ), 5 );
gtk_table_set_col_spacings( GTK_TABLE( table ), 5 );
adj = gtk_adjustment_new( portals.trans_3d, 0, 100, 1, 1, 1 );
transslider = gtk_hscale_new( GTK_ADJUSTMENT( adj ) );
gtk_widget_show( transslider );
gtk_table_attach( GTK_TABLE( table ), transslider, 0, 1, 0, 1,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_scale_set_draw_value( GTK_SCALE( transslider ), FALSE );
translabel = gtk_label_new( "" );
gtk_widget_show( translabel );
gtk_table_attach( GTK_TABLE( table ), translabel, 1, 2, 0, 1,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_misc_set_alignment( GTK_MISC( translabel ), 0.0, 0.0 );
gtk_signal_connect( adj, "value_changed", GTK_SIGNAL_FUNC( OnScrollTrans ), translabel );
adj = gtk_adjustment_new( portals.clip_range, 1, 128, 1, 1, 1 );
clipslider = gtk_hscale_new( GTK_ADJUSTMENT( adj ) );
gtk_widget_show( clipslider );
gtk_table_attach( GTK_TABLE( table ), clipslider, 0, 1, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_scale_set_draw_value( GTK_SCALE( clipslider ), FALSE );
cliplabel = gtk_label_new( "" );
gtk_widget_show( cliplabel );
gtk_table_attach( GTK_TABLE( table ), cliplabel, 1, 2, 1, 2,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_misc_set_alignment( GTK_MISC( cliplabel ), 0.0, 0.0 );
gtk_signal_connect( adj, "value_changed", GTK_SIGNAL_FUNC( OnScrollClip ), cliplabel );
hbox = gtk_hbox_new( TRUE, 5 );
gtk_widget_show( hbox );
gtk_box_pack_start( GTK_BOX( vbox2 ), hbox, TRUE, FALSE, 0 );
show3check = gtk_check_button_new_with_label( _( "Show" ) );
gtk_widget_show( show3check );
gtk_box_pack_start( GTK_BOX( hbox ), show3check, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT( show3check ), "toggled", GTK_SIGNAL_FUNC( OnConfig3d ), NULL );
portalcheck = gtk_check_button_new_with_label( _( "Portal cubic clipper" ) );
gtk_widget_show( portalcheck );
gtk_box_pack_start( GTK_BOX( hbox ), portalcheck, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT( portalcheck ), "toggled", GTK_SIGNAL_FUNC( OnClip ), NULL );
frame = gtk_frame_new( _( "2D View" ) );
gtk_widget_show( frame );
gtk_box_pack_start( GTK_BOX( vbox ), frame, TRUE, TRUE, 0 );
vbox2 = gtk_vbox_new( FALSE, 5 );
gtk_widget_show( vbox2 );
gtk_container_add( GTK_CONTAINER( frame ), vbox2 );
gtk_container_set_border_width( GTK_CONTAINER( vbox2 ), 5 );
hbox = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox );
gtk_box_pack_start( GTK_BOX( vbox2 ), hbox, TRUE, FALSE, 0 );
adj = gtk_adjustment_new( portals.width_2d, 2, 40, 1, 1, 1 );
lw2slider = gtk_hscale_new( GTK_ADJUSTMENT( adj ) );
gtk_widget_show( lw2slider );
gtk_box_pack_start( GTK_BOX( hbox ), lw2slider, TRUE, TRUE, 0 );
gtk_scale_set_draw_value( GTK_SCALE( lw2slider ), FALSE );
lw2label = gtk_label_new( "" );
gtk_widget_show( lw2label );
gtk_box_pack_start( GTK_BOX( hbox ), lw2label, FALSE, TRUE, 0 );
gtk_signal_connect( adj, "value_changed", GTK_SIGNAL_FUNC( OnScroll2d ), lw2label );
hbox = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox );
gtk_box_pack_start( GTK_BOX( vbox2 ), hbox, TRUE, FALSE, 0 );
button = gtk_button_new_with_label( _( "Color" ) );
gtk_widget_show( button );
gtk_box_pack_start( GTK_BOX( hbox ), button, FALSE, FALSE, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked", GTK_SIGNAL_FUNC( OnColor2d ), NULL );
gtk_widget_set_usize( button, 60, -2 );
aa2check = gtk_check_button_new_with_label( _( "Anti-Alias (May not work on some video cards)" ) );
gtk_widget_show( aa2check );
gtk_box_pack_start( GTK_BOX( hbox ), aa2check, TRUE, TRUE, 0 );
gtk_signal_connect( GTK_OBJECT( aa2check ), "toggled", GTK_SIGNAL_FUNC( OnAntiAlias2d ), NULL );
hbox = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox );
gtk_box_pack_start( GTK_BOX( vbox2 ), hbox, TRUE, FALSE, 0 );
show2check = gtk_check_button_new_with_label( _( "Show" ) );
gtk_widget_show( show2check );
gtk_box_pack_start( GTK_BOX( hbox ), show2check, FALSE, FALSE, 0 );
gtk_signal_connect( GTK_OBJECT( show2check ), "toggled", GTK_SIGNAL_FUNC( OnConfig2d ), NULL );
hbox = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
button = gtk_button_new_with_label( _( "OK" ) );
gtk_widget_show( button );
gtk_box_pack_end( GTK_BOX( hbox ), button, FALSE, FALSE, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( dialog_button_callback ), GINT_TO_POINTER( IDOK ) );
gtk_widget_set_usize( button, 60, -2 );
// initialize dialog
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( show2check ), portals.show_2d );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( aa2check ), portals.aa_2d );
Set2DText( lw2label );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( show3check ), portals.show_3d );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( depthcheck ), portals.fog );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( polyscheck ), portals.polygons );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( linescheck ), portals.lines );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( aa3check ), portals.aa_3d );
gtk_option_menu_set_history( GTK_OPTION_MENU( zlist ), portals.zbuffer );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( portalcheck ), portals.clip );
Set3DText( lw3label );
Set3DTransText( translabel );
SetClipText( cliplabel );
gtk_grab_add( dlg );
gtk_widget_show( dlg );
while ( loop )
gtk_main_iteration();
gtk_grab_remove( dlg );
gtk_widget_destroy( dlg );
}
static void replace_callback(GtkWidget *widget, GtkWidget *nothing)
{
Traces tcache;
int i;
Trptr tfirst, tlast;
struct symchain *symc, *symc_current;
gfloat interval;
if(is_replace_running) return;
is_replace_running = ~0;
gtk_grab_add(widget);
tfirst=NULL; tlast=NULL;
symc=NULL;
memcpy(&tcache,&traces,sizeof(Traces));
traces.total=0;
traces.first=traces.last=NULL;
GTK_ADJUSTMENT(pdata->adj)->upper = (gfloat)((num_rows>1)?num_rows-1:1);
interval = (gfloat)(num_rows/100.0);
pdata->oldvalue = -1.0;
for(i=0;i<num_rows;i++)
{
int len;
struct symbol *s, *t;
s=(struct symbol *)gtk_clist_get_row_data(GTK_CLIST(clist), i);
if(s->selected)
{
pdata->value = i;
if(((int)(pdata->value/interval))!=((int)(pdata->oldvalue/interval)))
{
gtk_progress_set_value (GTK_PROGRESS (pdata->pbar), i);
while (gtk_events_pending()) gtk_main_iteration();
}
pdata->oldvalue = i;
if((!s->vec_root)||(!autocoalesce))
{
AddNode(s->n, NULL);
}
else
{
len=0;
t=s->vec_root;
while(t)
{
if(t->selected)
{
if(len) t->selected=0;
symc_current=(struct symchain *)calloc_2(1,sizeof(struct symchain));
symc_current->next=symc;
symc_current->symbol=t;
symc=symc_current;
}
len++;
t=t->vec_chain;
}
if(len)add_vector_chain(s->vec_root, len);
}
}
}
while(symc)
{
symc->symbol->selected=1;
symc_current=symc;
symc=symc->next;
free_2(symc_current);
}
tfirst=traces.first; tlast=traces.last; /* cache for highlighting */
traces.buffercount=traces.total;
traces.buffer=traces.first;
traces.bufferlast=traces.last;
traces.first=tcache.first;
traces.last=tcache.last;
traces.total=tcache.total;
PasteBuffer();
traces.buffercount=tcache.buffercount;
traces.buffer=tcache.buffer;
traces.bufferlast=tcache.bufferlast;
CutBuffer();
while(tfirst)
{
tfirst->flags |= TR_HIGHLIGHT;
if(tfirst==tlast) break;
tfirst=tfirst->next;
}
MaxSignalLength();
signalarea_configure_event(signalarea, NULL);
wavearea_configure_event(wavearea, NULL);
gtk_progress_set_value (GTK_PROGRESS (pdata->pbar), 0.0);
pdata->oldvalue = -1.0;
gtk_grab_remove(widget);
is_replace_running=0;
}
static void
ep_ask_password (EPassMsg *msg)
{
GtkWidget *widget;
GtkWidget *container;
GtkWidget *action_area;
GtkWidget *content_area;
gint type = msg->flags & E_PASSWORDS_REMEMBER_MASK;
guint noreply = msg->noreply;
gboolean visible;
AtkObject *a11y;
msg->noreply = 1;
widget = gtk_dialog_new_with_buttons (
msg->title, msg->parent, 0,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
#if !GTK_CHECK_VERSION(2,90,7)
g_object_set (widget, "has-separator", FALSE, NULL);
#endif
gtk_dialog_set_default_response (
GTK_DIALOG (widget), GTK_RESPONSE_OK);
gtk_window_set_resizable (GTK_WINDOW (widget), FALSE);
gtk_window_set_transient_for (GTK_WINDOW (widget), msg->parent);
gtk_window_set_position (GTK_WINDOW (widget), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_container_set_border_width (GTK_CONTAINER (widget), 12);
password_dialog = GTK_DIALOG (widget);
action_area = gtk_dialog_get_action_area (password_dialog);
content_area = gtk_dialog_get_content_area (password_dialog);
/* Override GtkDialog defaults */
gtk_box_set_spacing (GTK_BOX (action_area), 12);
gtk_container_set_border_width (GTK_CONTAINER (action_area), 0);
gtk_box_set_spacing (GTK_BOX (content_area), 12);
gtk_container_set_border_width (GTK_CONTAINER (content_area), 0);
/* Table */
container = gtk_table_new (2, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (container), 12);
gtk_table_set_row_spacings (GTK_TABLE (container), 6);
gtk_table_set_row_spacing (GTK_TABLE (container), 0, 12);
gtk_table_set_row_spacing (GTK_TABLE (container), 1, 0);
gtk_widget_show (container);
gtk_box_pack_start (
GTK_BOX (content_area), container, FALSE, TRUE, 0);
/* Password Image */
widget = gtk_image_new_from_icon_name (
"dialog-password", GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0);
gtk_widget_show (widget);
gtk_table_attach (
GTK_TABLE (container), widget,
0, 1, 0, 3, GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
/* Password Label */
widget = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
gtk_label_set_markup (GTK_LABEL (widget), msg->prompt);
gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.5);
gtk_widget_show (widget);
gtk_table_attach (
GTK_TABLE (container), widget,
1, 2, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
/* Password Entry */
widget = gtk_entry_new ();
a11y = gtk_widget_get_accessible (widget);
visible = !(msg->flags & E_PASSWORDS_SECRET);
atk_object_set_description (a11y, msg->prompt);
gtk_entry_set_visibility (GTK_ENTRY (widget), visible);
gtk_entry_set_activates_default (GTK_ENTRY (widget), TRUE);
gtk_widget_grab_focus (widget);
gtk_widget_show (widget);
msg->entry = widget;
if ((msg->flags & E_PASSWORDS_REPROMPT)) {
ep_get_password (msg);
if (msg->password != NULL) {
gtk_entry_set_text (GTK_ENTRY (widget), msg->password);
g_free (msg->password);
msg->password = NULL;
}
}
gtk_table_attach (
GTK_TABLE (container), widget,
1, 2, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0);
/* Caps Lock Label */
widget = gtk_label_new (NULL);
gtk_widget_show (widget);
gtk_table_attach (
GTK_TABLE (container), widget,
1, 2, 2, 3, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect (
password_dialog, "key-release-event",
G_CALLBACK (update_capslock_state), widget);
g_signal_connect (
password_dialog, "focus-in-event",
G_CALLBACK (update_capslock_state), widget);
/* static password, shouldn't be remembered between sessions,
but will be remembered within the session beyond our control */
if (type != E_PASSWORDS_REMEMBER_NEVER) {
if (msg->flags & E_PASSWORDS_PASSPHRASE) {
widget = gtk_check_button_new_with_mnemonic (
(type == E_PASSWORDS_REMEMBER_FOREVER)
? _("_Remember this passphrase")
: _("_Remember this passphrase for"
" the remainder of this session"));
} else {
widget = gtk_check_button_new_with_mnemonic (
(type == E_PASSWORDS_REMEMBER_FOREVER)
? _("_Remember this password")
: _("_Remember this password for"
" the remainder of this session"));
}
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (widget), *msg->remember);
if (msg->flags & E_PASSWORDS_DISABLE_REMEMBER)
gtk_widget_set_sensitive (widget, FALSE);
gtk_widget_show (widget);
msg->check = widget;
gtk_table_attach (
GTK_TABLE (container), widget,
1, 2, 3, 4, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
}
msg->noreply = noreply;
g_signal_connect (
password_dialog, "response",
G_CALLBACK (pass_response), msg);
if (msg->parent) {
gtk_dialog_run (GTK_DIALOG (password_dialog));
} else {
gtk_window_present (GTK_WINDOW (password_dialog));
/* workaround GTK+ bug (see Gnome's bugzilla bug #624229) */
gtk_grab_add (GTK_WIDGET (password_dialog));
}
}
static gint ci_add( GtkWidget *widget, gpointer data )
{
GtkWidget *window, *w, *vbox, *vbox2, *hbox, *frame, *parameters;
GtkWidget *eventWidget[EVENT_COUNT];
EMessageBoxReturn ret;
int i, loop = 1;
GSList *eventTypeRadio = NULL;
// char buf[128];
if( !GetCurrentCam() )
return TRUE;
// create the window
window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW (window), "Add Event" );
gtk_signal_connect( GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC( dialog_delete_callback ), NULL );
gtk_signal_connect( GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC( gtk_widget_destroy ), NULL );
gtk_window_set_transient_for( GTK_WINDOW( window ), GTK_WINDOW( g_pCameraInspectorWnd ) );
g_object_set_data (G_OBJECT (window), "loop", &loop);
g_object_set_data (G_OBJECT (window), "ret", &ret);
gtk_widget_realize (window);
// fill the window
vbox = gtk_vbox_new( FALSE, 5 );
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show( vbox );
// -------------------------- //
hbox = gtk_hbox_new( FALSE, 5 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
gtk_widget_show( hbox );
frame = gtk_frame_new( "Type" );
gtk_box_pack_start( GTK_BOX( hbox ), frame, TRUE, TRUE, 0 );
gtk_widget_show( frame );
vbox2 = gtk_vbox_new( FALSE, 5 );
gtk_container_add( GTK_CONTAINER( frame ), vbox2 );
gtk_container_set_border_width( GTK_CONTAINER (vbox2), 5 );
gtk_widget_show( vbox2 );
// -------------------------- //
for( i = 1; i < EVENT_COUNT; i++ ) {
eventWidget[i] = gtk_radio_button_new_with_label( eventTypeRadio, camEventStr[i] );
gtk_box_pack_start( GTK_BOX( vbox2 ), eventWidget[i], FALSE, FALSE, 3 );
gtk_widget_show( eventWidget[i] );
eventTypeRadio = gtk_radio_button_group( GTK_RADIO_BUTTON( eventWidget[i] ) );
if( camEventFlags[i][1] == false )
gtk_widget_set_sensitive (eventWidget[i], FALSE);
}
// -------------------------- //
hbox = gtk_hbox_new( FALSE, 5 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
gtk_widget_show( hbox );
w = gtk_label_new( "Parameters:" );
gtk_box_pack_start( GTK_BOX( hbox ), w, FALSE, FALSE, 0 );
gtk_widget_show( w );
parameters = gtk_entry_new();
gtk_box_pack_start( GTK_BOX( hbox ), parameters, TRUE, TRUE, 0 );
gtk_widget_show( parameters );
// -------------------------- //
w = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 2);
gtk_widget_show (w);
// -------------------------- //
hbox = gtk_hbox_new( FALSE, 5 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox, FALSE, FALSE, 0 );
gtk_widget_show( hbox );
w = gtk_button_new_with_label ("Ok");
gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (w), "clicked", GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (eIDOK));
gtk_widget_show (w);
GTK_WIDGET_SET_FLAGS( w, GTK_CAN_DEFAULT );
gtk_widget_grab_default( w );
w = gtk_button_new_with_label ("Cancel");
gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (w), "clicked", GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (eIDCANCEL));
gtk_widget_show (w);
ret = eIDCANCEL;
// -------------------------- //
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);
gtk_widget_show (window);
gtk_grab_add (window);
bool dialogError = TRUE;
while (dialogError) {
loop = 1;
while (loop)
gtk_main_iteration ();
dialogError = FALSE;
if( ret == eIDOK ) {
const char *str = gtk_entry_get_text( GTK_ENTRY(parameters) );
if( !camEventFlags[i][0] || ( str && str[0] ) ) {
int type = 0;
// GList *li;
for( type = 1; type < EVENT_COUNT; type++ ) {
if( gtk_toggle_button_get_active( (GtkToggleButton*)eventWidget[type] ) )
break;
}
// Add the event
GetCurrentCam()->GetCam()->addEvent( static_cast<idCameraEvent::eventType>(type), str, (long)(g_pTimeLine->value) );
// Refresh event list
RefreshEventList();
} else {
dialogError = TRUE;
}
}
}
gtk_grab_remove (window);
gtk_widget_destroy (window);
return TRUE;
}
