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; }