//
// AbiGOComponent_Create
// -------------------
// This is the function that we actually call to insert a new intially empty component.
bool
AbiGOComponent_Create (G_GNUC_UNUSED AV_View* v, G_GNUC_UNUSED EV_EditMethodCallData *d)
{
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
XAP_UnixFrameImpl *pFrameImpl = static_cast<XAP_UnixFrameImpl*>(pFrame->getFrameImpl());
std::string cancel, ok;
const XAP_StringSet *pSS = XAP_App::getApp()->getStringSet();
pSS->getValueUTF8(XAP_STRING_ID_DLG_Cancel, cancel);
pSS->getValueUTF8(XAP_STRING_ID_DLG_OK, ok);
GtkDialog *dialog = GTK_DIALOG (gtk_dialog_new_with_buttons ("New Object",
GTK_WINDOW(pFrameImpl->getTopLevelWindow()),
(GtkDialogFlags) (GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
convertMnemonics(cancel).c_str(), GTK_RESPONSE_CANCEL,
convertMnemonics(ok).c_str(), GTK_RESPONSE_OK, NULL));
GtkListStore *list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
GtkWidget *w = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list));
g_signal_connect_swapped(w, "button-press-event", G_CALLBACK(button_press_cb), dialog);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Object type:", renderer, "text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (w), column);
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW (w));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_BROWSE);
GtkTreeIter iter;
GSList *l = mime_types;
gchar const *mime_type;
while (l) {
mime_type = (gchar const *) l->data;
if (strcmp(mime_type, "application/mathml+xml")
&& go_components_get_priority(mime_type) >= GO_MIME_PRIORITY_PARTIAL)
{
gtk_list_store_append (list, &iter);
gtk_list_store_set (list, &iter,
0, go_mime_type_get_description (mime_type),
1, mime_type,
-1);
}
l = l->next;
}
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area(dialog)), w, false, false, 0);
gtk_widget_show_all (GTK_WIDGET(dialog));
gint result = gtk_dialog_run (dialog);
if (result == GTK_RESPONSE_OK &&
gtk_tree_selection_get_selected (sel, NULL, &iter)) {
gtk_tree_model_get (GTK_TREE_MODEL (list), &iter, 1, &mime_type, -1);
GOComponent *component = go_component_new_by_mime_type (mime_type);
go_component_set_inline (component, true);
go_component_set_use_font_from_app (component, true);
g_signal_connect (G_OBJECT (component), "changed",
G_CALLBACK (changed_cb), NULL);
GtkWindow *win = go_component_edit(component);
gtk_window_set_transient_for(win, GTK_WINDOW(pFrameImpl->getTopLevelWindow()));
}
gtk_widget_destroy (GTK_WIDGET (dialog));
return result == GTK_RESPONSE_OK;
}
/*!
* Localizes the label of a widget given the string id
* Ampersands will be converted to underscores/mnemonics
*/
void localizeLabelUnderline(GtkWidget * widget, const XAP_StringSet * pSS, XAP_String_Id id)
{
UT_UTF8String s;
pSS->getValueUTF8(id,s);
gchar * newlbl = g_strdup(s.utf8_str());
UT_ASSERT(newlbl);
convertMnemonics(newlbl);
gtk_label_set_text_with_mnemonic (GTK_LABEL(widget), newlbl);
FREEP(newlbl);
}
/*!
* Localizes a button given the string id
* Ampersands will be converted to underscores/mnemonics
*/
void localizeButtonUnderline(GtkWidget * widget, const XAP_StringSet * pSS, XAP_String_Id id)
{
UT_UTF8String s;
pSS->getValueUTF8(id,s);
gchar * newlbl = g_strdup(s.utf8_str());
UT_ASSERT(newlbl);
convertMnemonics(newlbl);
gtk_button_set_use_underline (GTK_BUTTON(widget), TRUE);
gtk_button_set_label (GTK_BUTTON(widget), newlbl);
FREEP(newlbl);
}
/*!
* Localizes a button given the string id
* It formats its label using the current button label as a format
* string. It is assumed to be something like
* "<span size="larger">%s</span>".
* Note that in addition to doing markup, ampersands will be converted
* to underscores/mnemonic since this makes sense for buttons
*/
void localizeButtonMarkup(GtkWidget * widget, const XAP_StringSet * pSS, XAP_String_Id id)
{
UT_UTF8String s;
pSS->getValueUTF8(id,s);
gchar * newlbl = g_strdup(s.utf8_str());
UT_ASSERT(newlbl);
convertMnemonics(newlbl);
UT_String markupStr(UT_String_sprintf(gtk_button_get_label (GTK_BUTTON(widget)), newlbl));
gtk_button_set_use_underline (GTK_BUTTON(widget), TRUE);
gtk_button_set_label (GTK_BUTTON(widget), markupStr.c_str());
// by default, they don't like markup, so we teach them
GtkWidget * button_child = gtk_bin_get_child (GTK_BIN(widget));
if (GTK_IS_LABEL (button_child))
gtk_label_set_use_markup (GTK_LABEL(button_child), TRUE);
FREEP(newlbl);
}
void XAP_UnixDialog_MessageBox::runModal(XAP_Frame * pFrame)
{
XAP_UnixFrameImpl * pUnixFrameImpl = static_cast<XAP_UnixFrameImpl *>(pFrame->getFrameImpl());
UT_return_if_fail(pUnixFrameImpl);
XAP_UnixApp * pApp = static_cast<XAP_UnixApp *>(XAP_App::getApp());
UT_return_if_fail(pApp);
GtkWidget * message = 0; // initialize to prevent compiler warning
GtkWindow * toplevel;
toplevel = GTK_WINDOW(pUnixFrameImpl->getTopLevelWindow());
int dflFlags = GTK_DIALOG_MODAL;
int dflResponse = GTK_RESPONSE_OK;
switch (m_buttons)
{
case b_O:
// just put up an information box
message = gtk_message_dialog_new ( toplevel, GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"%s",
m_szMessage ) ;
break;
case b_YN:
// YES - NO - most certainly a question
message = gtk_message_dialog_new ( toplevel, GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
"%s",
m_szMessage ) ;
if(m_defaultAnswer == XAP_Dialog_MessageBox::a_YES)
{
gtk_dialog_set_default_response (GTK_DIALOG(message),
GTK_RESPONSE_YES);
}
else
{
gtk_dialog_set_default_response (GTK_DIALOG(message),
GTK_RESPONSE_NO);
}
break;
case b_YNC:
{
// YES - NO - CANCEL
// this is only used for saving files.
#ifndef EMBEDDED_TARGET
std::string no, cancel, save;
std::string labelText;
const XAP_StringSet * pSS = pApp->getStringSet ();
message = gtk_dialog_new_with_buttons("",
toplevel,
static_cast<GtkDialogFlags>(dflFlags),
NULL, NULL);
pSS->getValueUTF8(XAP_STRING_ID_DLG_Exit_CloseWithoutSaving, no);
pSS->getValueUTF8(XAP_STRING_ID_DLG_Cancel, cancel);
pSS->getValueUTF8(XAP_STRING_ID_DLG_Save, save);
gtk_dialog_add_buttons(GTK_DIALOG(message),
convertMnemonics(no).c_str(),
GTK_RESPONSE_NO,
convertMnemonics(cancel).c_str(),
GTK_RESPONSE_CANCEL,
convertMnemonics(save).c_str(),
GTK_RESPONSE_YES,
NULL);
dflResponse = GTK_RESPONSE_YES;
GtkWidget * label = gtk_label_new(NULL);
const char * separator;
separator = m_szSecondaryMessage ? "\n\n" : "";
gchar * msg = g_markup_escape_text (m_szMessage, -1);
labelText = UT_std_string_sprintf(
"<span weight=\"bold\" size=\"larger\">%s</span>%s%s",
msg, separator, m_szSecondaryMessage);
g_free (msg); msg = NULL;
gtk_label_set_markup(GTK_LABEL(label), labelText.c_str());
GtkWidget * hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (hbox),
gtk_image_new_from_icon_name("dialog-warning",
GTK_ICON_SIZE_DIALOG),
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), label,
TRUE, TRUE, 0);
GtkBox *content_area = GTK_BOX (gtk_dialog_get_content_area(GTK_DIALOG(message)));
gtk_box_pack_start (content_area, hbox, FALSE, FALSE, 0);
gtk_box_set_spacing(content_area, 12);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 6);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_widget_show_all (hbox);
#else
message = gtk_message_dialog_new (toplevel,
static_cast<GtkDialogFlags>(dflFlags),
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
"%s",
m_szMessage);
gtk_dialog_add_buttons(GTK_DIALOG(message),
GTK_STOCK_NO,
GTK_RESPONSE_NO,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_YES,
GTK_RESPONSE_YES,
NULL);
#endif
gtk_dialog_set_default_response (GTK_DIALOG(message),
GTK_RESPONSE_CANCEL);
break;
}
default:
UT_ASSERT_NOT_REACHED();
}
// set the title to '', as per GNOME HIG, Section 3, Alerts
gtk_window_set_title (GTK_WINDOW(message), "");
UT_ASSERT(message);
switch ( abiRunModalDialog ( GTK_DIALOG(message), pFrame,
this, dflResponse, true, ATK_ROLE_ALERT ) )
{
case GTK_RESPONSE_OK:
m_answer = XAP_Dialog_MessageBox::a_OK;
break;
case GTK_RESPONSE_YES:
m_answer = XAP_Dialog_MessageBox::a_YES;
break;
case GTK_RESPONSE_NO:
m_answer = XAP_Dialog_MessageBox::a_NO;
break;
case GTK_RESPONSE_CANCEL:
default:
m_answer = XAP_Dialog_MessageBox::a_CANCEL; break;
}
}
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;
}
