void AP_UnixDialog_FormatTOC::_createLevelItems(void)
{
const XAP_StringSet * pSS = XAP_App::getApp()->getStringSet ();
UT_UTF8String s;
GtkComboBox *combo;
combo = GTK_COMBO_BOX(_getWidget("wLevelOption"));
XAP_makeGtkComboBoxText(combo, G_TYPE_INT);
pSS->getValueUTF8(AP_STRING_ID_DLG_FormatTOC_Level1,s);
XAP_appendComboBoxTextAndInt(combo, s.utf8_str(), 1);
pSS->getValueUTF8(AP_STRING_ID_DLG_FormatTOC_Level2,s);
XAP_appendComboBoxTextAndInt(combo, s.utf8_str(), 2);
pSS->getValueUTF8(AP_STRING_ID_DLG_FormatTOC_Level3,s);
XAP_appendComboBoxTextAndInt(combo, s.utf8_str(), 3);
pSS->getValueUTF8(AP_STRING_ID_DLG_FormatTOC_Level4,s);
XAP_appendComboBoxTextAndInt(combo, s.utf8_str(), 4);
gtk_combo_box_set_active(combo, 0);
//////////////////////////////////////////////////////////////////////////////
combo = GTK_COMBO_BOX(_getWidget("wDetailsLevel"));
XAP_makeGtkComboBoxText(combo, G_TYPE_INT);
pSS->getValueUTF8(AP_STRING_ID_DLG_FormatTOC_Level1,s);
XAP_appendComboBoxTextAndInt(combo, s.utf8_str(), 1);
pSS->getValueUTF8(AP_STRING_ID_DLG_FormatTOC_Level2,s);
XAP_appendComboBoxTextAndInt(combo, s.utf8_str(), 2);
pSS->getValueUTF8(AP_STRING_ID_DLG_FormatTOC_Level3,s);
XAP_appendComboBoxTextAndInt(combo, s.utf8_str(), 3);
pSS->getValueUTF8(AP_STRING_ID_DLG_FormatTOC_Level4,s);
XAP_appendComboBoxTextAndInt(combo, s.utf8_str(), 4);
gtk_combo_box_set_active(combo, 0);
}
GtkWidget * AP_UnixDialog_Paragraph::_constructWindowContents(GtkWidget *windowMain)
{
// grab the string set
const XAP_StringSet * pSS = XAP_App::getApp()->getStringSet();
GtkWidget * vboxContents;
GtkWidget * tabMain;
GtkWidget * boxSpacing;
GtkWidget * hboxAlignment;
GtkComboBox * listAlignment;
GtkWidget * spinbuttonLeft;
GtkWidget * spinbuttonRight;
GtkComboBox * listSpecial;
GtkWidget * spinbuttonBy;
GtkWidget * spinbuttonBefore;
GtkWidget * spinbuttonAfter;
GtkComboBox * listLineSpacing;
GtkWidget * spinbuttonAt;
GtkWidget * labelAlignment;
GtkWidget * labelBy;
GtkWidget * hboxIndentation;
GtkWidget * labelIndentation;
GtkWidget * labelLeft;
GtkWidget * labelRight;
GtkWidget * labelSpecial;
GtkWidget * hseparator3;
GtkWidget * hboxSpacing;
GtkWidget * labelSpacing;
GtkWidget * labelAfter;
GtkWidget * labelLineSpacing;
GtkWidget * labelAt;
GtkWidget * hseparator1;
GtkWidget * labelBefore;
GtkWidget * labelIndents;
GtkWidget * boxBreaks;
GtkWidget * hboxPagination;
GtkWidget * labelPagination;
GtkWidget * hseparator5;
GtkWidget * checkbuttonWidowOrphan;
GtkWidget * checkbuttonKeepLines;
GtkWidget * checkbuttonPageBreak;
GtkWidget * checkbuttonSuppress;
GtkWidget * checkbuttonHyphenate;
GtkWidget * hseparator6;
GtkWidget * checkbuttonKeepNext;
GtkWidget * labelBreaks;
GtkWidget * checkbuttonDomDirection;
gchar * unixstr = NULL;
vboxContents = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vboxContents);
tabMain = gtk_notebook_new ();
gtk_widget_show (tabMain);
gtk_box_pack_start (GTK_BOX (vboxContents), tabMain, FALSE, TRUE, 0);
// "Indents and Spacing" page
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
boxSpacing = gtk_table_new (3, 4, FALSE);
#else
boxSpacing = gtk_table_new (7, 4, FALSE);
#endif
gtk_widget_show (boxSpacing);
gtk_table_set_row_spacings (GTK_TABLE(boxSpacing), 5);
gtk_table_set_col_spacings (GTK_TABLE(boxSpacing), 5);
gtk_container_set_border_width (GTK_CONTAINER(boxSpacing), 5);
UT_UTF8String s;
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_TabLabelIndentsAndSpacing,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelIndents = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_widget_show (labelIndents);
gtk_notebook_append_page (GTK_NOTEBOOK (tabMain), boxSpacing, labelIndents);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelAlignment,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelAlignment = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_widget_show (labelAlignment);
gtk_table_attach ( GTK_TABLE(boxSpacing), labelAlignment, 0,1, 0,1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_label_set_justify (GTK_LABEL (labelAlignment), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (labelAlignment), 1, 0.5);
hboxAlignment = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_widget_show (hboxAlignment);
listAlignment = GTK_COMBO_BOX(gtk_combo_box_new ());
XAP_makeGtkComboBoxText(listAlignment, G_TYPE_INT);
/**/ g_object_set_data(G_OBJECT(listAlignment), WIDGET_ID_TAG, (gpointer) id_MENU_ALIGNMENT);
gtk_widget_show (GTK_WIDGET(listAlignment));
gtk_box_pack_start (GTK_BOX (hboxAlignment), GTK_WIDGET(listAlignment), FALSE, FALSE, 0);
gtk_table_attach ( GTK_TABLE(boxSpacing), hboxAlignment, 1,2, 0,1,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL), 0, 0);
XAP_appendComboBoxTextAndInt(listAlignment, " ", 0); // add an empty menu option to fix bug 594
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_AlignLeft,s);
XAP_appendComboBoxTextAndInt(listAlignment, s.utf8_str(), align_LEFT);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_AlignCentered,s);
XAP_appendComboBoxTextAndInt(listAlignment, s.utf8_str(), align_CENTERED);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_AlignRight,s);
XAP_appendComboBoxTextAndInt(listAlignment, s.utf8_str(), align_RIGHT);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_AlignJustified,s);
XAP_appendComboBoxTextAndInt(listAlignment, s.utf8_str(), align_JUSTIFIED);
gtk_combo_box_set_active(listAlignment, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_DomDirection,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
checkbuttonDomDirection = gtk_check_button_new_with_label (unixstr);
FREEP(unixstr);
/**/ g_object_set_data(G_OBJECT(checkbuttonDomDirection), WIDGET_ID_TAG, (gpointer) id_CHECK_DOMDIRECTION);
gtk_widget_show (checkbuttonDomDirection);
gtk_table_attach ( GTK_TABLE(boxSpacing), checkbuttonDomDirection, 3,4,0,1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0 );
hboxIndentation = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_widget_show (hboxIndentation);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelIndentation,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelIndentation = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_widget_show (labelIndentation);
gtk_box_pack_start (GTK_BOX (hboxIndentation), labelIndentation, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (labelIndentation), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (labelIndentation), 0, 0.5);
hseparator3 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_show (hseparator3);
gtk_box_pack_start (GTK_BOX (hboxIndentation), hseparator3, TRUE, TRUE, 0);
gtk_table_attach ( GTK_TABLE(boxSpacing), hboxIndentation, 0,4, 1,2,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL), 0, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelLeft,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelLeft = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_widget_show (labelLeft);
gtk_table_attach ( GTK_TABLE(boxSpacing), labelLeft, 0,1, 2,3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_label_set_justify (GTK_LABEL (labelLeft), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (labelLeft), 1, 0.5);
// spinbuttonLeft_adj = gtk_adjustment_new (0, 0, 100, 0.1, 10, 10);
// spinbuttonLeft = gtk_spin_button_new (NULL, 1, 1);
spinbuttonLeft = gtk_entry_new();
g_object_ref (spinbuttonLeft);
g_object_set_data_full (G_OBJECT (windowMain), "spinbuttonLeft", spinbuttonLeft,
(GDestroyNotify) g_object_unref);
/**/ g_object_set_data(G_OBJECT(spinbuttonLeft), WIDGET_ID_TAG, (gpointer) id_SPIN_LEFT_INDENT);
gtk_widget_show (spinbuttonLeft);
gtk_table_attach ( GTK_TABLE(boxSpacing), spinbuttonLeft, 1,2, 2,3,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL), 0, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelRight,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelRight = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_widget_show (labelRight);
gtk_table_attach ( GTK_TABLE(boxSpacing), labelRight, 0,1, 3,4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_label_set_justify (GTK_LABEL (labelRight), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (labelRight), 1, 0.5);
// spinbuttonRight_adj = gtk_adjustment_new (0, 0, 100, 0.1, 10, 10);
// spinbuttonRight = gtk_spin_button_new (NULL, 1, 1);
spinbuttonRight = gtk_entry_new();
/**/ g_object_set_data(G_OBJECT(spinbuttonRight), WIDGET_ID_TAG, (gpointer) id_SPIN_RIGHT_INDENT);
gtk_widget_show (spinbuttonRight);
gtk_table_attach ( GTK_TABLE(boxSpacing), spinbuttonRight, 1,2, 3,4,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL), 0, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelSpecial,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelSpecial = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_widget_show (labelSpecial);
gtk_table_attach ( GTK_TABLE(boxSpacing), labelSpecial, 2,3, 2,3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
gtk_label_set_justify (GTK_LABEL (labelSpecial), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (labelSpecial), 1, 0.5);
#else
gtk_label_set_justify (GTK_LABEL (labelSpecial), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (labelSpecial), 0, 0.5);
#endif
listSpecial = GTK_COMBO_BOX(gtk_combo_box_new ());
XAP_makeGtkComboBoxText(listSpecial, G_TYPE_INT);
/**/ g_object_set_data(G_OBJECT(listSpecial), WIDGET_ID_TAG, (gpointer) id_MENU_SPECIAL_INDENT);
gtk_widget_show (GTK_WIDGET(listSpecial));
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
gtk_table_attach ( GTK_TABLE(boxSpacing), (GtkWidget*)listSpecial, 3, 4, 2, 3,
(GtkAttachOptions) (GTK_SHRINK),
(GtkAttachOptions) (GTK_FILL), 0, 0);
#else
gtk_table_attach ( GTK_TABLE(boxSpacing), (GtkWidget*)listSpecial, 2,3, 3,4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
#endif
XAP_appendComboBoxTextAndInt(listSpecial, " ", 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_SpecialNone,s);
XAP_appendComboBoxTextAndInt(listSpecial, s.utf8_str(), indent_NONE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_SpecialFirstLine,s);
XAP_appendComboBoxTextAndInt(listSpecial, s.utf8_str(), indent_FIRSTLINE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_SpecialHanging,s);
XAP_appendComboBoxTextAndInt(listSpecial, s.utf8_str(), indent_HANGING);
gtk_combo_box_set_active(listSpecial, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelBy,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelBy = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_widget_show (labelBy);
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
gtk_table_attach ( GTK_TABLE(boxSpacing), labelBy, 2, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_label_set_justify (GTK_LABEL (labelBy), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (labelBy), 1, 0.5);
#else
gtk_table_attach ( GTK_TABLE(boxSpacing), labelBy, 3,4, 2,3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_label_set_justify (GTK_LABEL (labelBy), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (labelBy), 0, 0.5);
#endif
// spinbuttonBy_adj = gtk_adjustment_new (0.5, 0, 100, 0.1, 10, 10);
// spinbuttonBy = gtk_spin_button_new (NULL, 1, 1);
spinbuttonBy = gtk_entry_new();
/**/ g_object_set_data(G_OBJECT(spinbuttonBy), WIDGET_ID_TAG, (gpointer) id_SPIN_SPECIAL_INDENT);
gtk_widget_show (spinbuttonBy);
gtk_table_attach ( GTK_TABLE(boxSpacing), spinbuttonBy, 3,4, 3,4,
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
(GtkAttachOptions) (GTK_SHRINK|GTK_EXPAND),
#else
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
#endif
(GtkAttachOptions) (GTK_FILL), 0, 0);
hboxSpacing = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_widget_show (hboxSpacing);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelSpacing,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelSpacing = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_box_pack_start (GTK_BOX (hboxSpacing), labelSpacing, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (labelSpacing), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (labelSpacing), 0, 0.5);
hseparator1 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (hboxSpacing), hseparator1, TRUE, TRUE, 0);
gtk_table_attach ( GTK_TABLE(boxSpacing), hboxSpacing, 0,4, 4,5,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL), 0, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelBefore,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelBefore = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_table_attach ( GTK_TABLE(boxSpacing), labelBefore, 0,1, 5,6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_label_set_justify (GTK_LABEL (labelBefore), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (labelBefore), 1, 0.5);
// spinbuttonBefore_adj = gtk_adjustment_new (0, 0, 1500, 0.1, 10, 10);
// spinbuttonBefore = gtk_spin_button_new (NULL, 1, 1);
spinbuttonBefore = gtk_entry_new();
/**/ g_object_set_data(G_OBJECT(spinbuttonBefore), WIDGET_ID_TAG, (gpointer) id_SPIN_BEFORE_SPACING);
gtk_table_attach ( GTK_TABLE(boxSpacing), spinbuttonBefore, 1,2, 5,6,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL), 0, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelAfter,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelAfter = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_table_attach ( GTK_TABLE(boxSpacing), labelAfter, 0,1, 6,7,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_label_set_justify (GTK_LABEL (labelAfter), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment (GTK_MISC (labelAfter), 1, 0.5);
// spinbuttonAfter_adj = gtk_adjustment_new (0, 0, 1500, 0.1, 10, 10);
// spinbuttonAfter = gtk_spin_button_new (NULL, 1, 1);
spinbuttonAfter = gtk_entry_new();
/**/ g_object_set_data(G_OBJECT(spinbuttonAfter), WIDGET_ID_TAG, (gpointer) id_SPIN_AFTER_SPACING);
gtk_table_attach ( GTK_TABLE(boxSpacing), spinbuttonAfter, 1,2, 6,7,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL), 0, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelLineSpacing,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelLineSpacing = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_table_attach ( GTK_TABLE(boxSpacing), labelLineSpacing, 2,3, 5,6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_label_set_justify (GTK_LABEL (labelLineSpacing), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (labelLineSpacing), 0, 0.5);
listLineSpacing = GTK_COMBO_BOX(gtk_combo_box_new ());
XAP_makeGtkComboBoxText(listLineSpacing, G_TYPE_INT);
/**/ g_object_set_data(G_OBJECT(listLineSpacing), WIDGET_ID_TAG, (gpointer) id_MENU_SPECIAL_SPACING);
gtk_table_attach ( GTK_TABLE(boxSpacing), GTK_WIDGET(listLineSpacing), 2,3, 6,7,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
XAP_appendComboBoxTextAndInt(listLineSpacing, " ", 0); // add an empty menu option to fix bug 594
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_SpacingSingle,s);
XAP_appendComboBoxTextAndInt(listLineSpacing, s.utf8_str(), spacing_SINGLE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_SpacingHalf,s);
XAP_appendComboBoxTextAndInt(listLineSpacing, s.utf8_str(), spacing_ONEANDHALF);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_SpacingDouble,s);
XAP_appendComboBoxTextAndInt(listLineSpacing, s.utf8_str(), spacing_DOUBLE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_SpacingAtLeast,s);
XAP_appendComboBoxTextAndInt(listLineSpacing, s.utf8_str(), spacing_ATLEAST);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_SpacingExactly,s);
XAP_appendComboBoxTextAndInt(listLineSpacing, s.utf8_str(), spacing_EXACTLY);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_SpacingMultiple,s);
XAP_appendComboBoxTextAndInt(listLineSpacing, s.utf8_str(), spacing_MULTIPLE);
gtk_combo_box_set_active(listLineSpacing, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelAt,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelAt = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_table_attach ( GTK_TABLE(boxSpacing), labelAt, 3,4, 5,6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_label_set_justify (GTK_LABEL (labelAt), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (labelAt), 0, 0.5);
// spinbuttonAt_adj = gtk_adjustment_new (0.5, 0, 100, 0.1, 10, 10);
// spinbuttonAt = gtk_spin_button_new (NULL, 1, 1);
spinbuttonAt = gtk_entry_new();
/**/ g_object_set_data(G_OBJECT(spinbuttonAt), WIDGET_ID_TAG, (gpointer) id_SPIN_SPECIAL_SPACING);
gtk_table_attach ( GTK_TABLE(boxSpacing), spinbuttonAt, 3,4, 6,7,
(GtkAttachOptions) (GTK_FILL|GTK_EXPAND),
(GtkAttachOptions) (GTK_FILL), 0, 0);
//TODO: In hildon only hide components for future features
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
#else
gtk_widget_show (labelSpacing);
gtk_widget_show (hseparator1);
gtk_widget_show (labelBefore);
gtk_widget_show (spinbuttonBefore);
gtk_widget_show (labelAfter);
gtk_widget_show (spinbuttonAfter);
gtk_widget_show (labelLineSpacing);
gtk_widget_show (GTK_WIDGET(listLineSpacing));
gtk_widget_show (labelAt);
gtk_widget_show (spinbuttonAt);
#endif /* HAVE_HILDON */
// The "Line and Page Breaks" page
boxBreaks = gtk_table_new (6, 2, FALSE);
gtk_widget_show (boxBreaks);
gtk_table_set_row_spacings (GTK_TABLE(boxBreaks), 5);
gtk_table_set_col_spacings (GTK_TABLE(boxBreaks), 5);
gtk_container_set_border_width (GTK_CONTAINER(boxBreaks), 5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_TabLabelLineAndPageBreaks,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelBreaks = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_widget_show (labelBreaks);
gtk_notebook_append_page (GTK_NOTEBOOK (tabMain), boxBreaks, labelBreaks);
// Pagination headline
hboxPagination = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_widget_show (hboxPagination);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelPagination,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelPagination = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_widget_show (labelPagination);
gtk_box_pack_start (GTK_BOX (hboxPagination), labelPagination, FALSE, FALSE, 0);
hseparator5 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_show (hseparator5);
gtk_box_pack_start (GTK_BOX (hboxPagination), hseparator5, TRUE, TRUE, 0);
gtk_table_attach ( GTK_TABLE(boxBreaks), hboxPagination, 0,2, 0,1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
// Pagination toggles
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_PushWidowOrphanControl,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
checkbuttonWidowOrphan = gtk_check_button_new_with_label (unixstr);
FREEP(unixstr);
/**/ g_object_set_data(G_OBJECT(checkbuttonWidowOrphan), WIDGET_ID_TAG, (gpointer) id_CHECK_WIDOW_ORPHAN);
gtk_widget_show (checkbuttonWidowOrphan);
gtk_table_attach ( GTK_TABLE(boxBreaks), checkbuttonWidowOrphan, 0,1, 1,2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0 );
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_PushKeepWithNext,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
checkbuttonKeepNext = gtk_check_button_new_with_label (unixstr);
FREEP(unixstr);
/**/ g_object_set_data(G_OBJECT(checkbuttonKeepNext), WIDGET_ID_TAG, (gpointer) id_CHECK_KEEP_NEXT);
gtk_widget_show (checkbuttonKeepNext);
gtk_table_attach ( GTK_TABLE(boxBreaks), checkbuttonKeepNext, 1,2, 1,2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0 );
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_PushKeepLinesTogether,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
checkbuttonKeepLines = gtk_check_button_new_with_label (unixstr);
FREEP(unixstr);
/**/ g_object_set_data(G_OBJECT(checkbuttonKeepLines), WIDGET_ID_TAG, (gpointer) id_CHECK_KEEP_LINES);
gtk_widget_show (checkbuttonKeepLines);
gtk_table_attach ( GTK_TABLE(boxBreaks), checkbuttonKeepLines, 0,1, 2,3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0 );
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_PushPageBreakBefore,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
checkbuttonPageBreak = gtk_check_button_new_with_label (unixstr);
FREEP(unixstr);
/**/ g_object_set_data(G_OBJECT(checkbuttonPageBreak), WIDGET_ID_TAG, (gpointer) id_CHECK_PAGE_BREAK);
gtk_widget_show (checkbuttonPageBreak);
gtk_table_attach ( GTK_TABLE(boxBreaks), checkbuttonPageBreak, 1,2, 2,3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0 );
hseparator6 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_show (hseparator6);
gtk_table_attach ( GTK_TABLE(boxBreaks), hseparator6, 0,2, 3,4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0 );
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_PushSuppressLineNumbers,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
checkbuttonSuppress = gtk_check_button_new_with_label (unixstr);
FREEP(unixstr);
/**/ g_object_set_data(G_OBJECT(checkbuttonSuppress), WIDGET_ID_TAG, (gpointer) id_CHECK_SUPPRESS);
gtk_widget_show (checkbuttonSuppress);
gtk_table_attach ( GTK_TABLE(boxBreaks), checkbuttonSuppress, 0,1, 4,5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0 );
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_PushNoHyphenate,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
checkbuttonHyphenate = gtk_check_button_new_with_label (unixstr);
FREEP(unixstr);
/**/ g_object_set_data(G_OBJECT(checkbuttonHyphenate), WIDGET_ID_TAG, (gpointer) id_CHECK_NO_HYPHENATE);
gtk_widget_show (checkbuttonHyphenate);
gtk_table_attach ( GTK_TABLE(boxBreaks), checkbuttonHyphenate, 0,1, 5,6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0 );
// End of notebook. Next comes the preview area.
#if !defined(EMBEDDED_TARGET) || EMBEDDED_TARGET != EMBEDDED_TARGET_HILDON
GtkWidget * hboxPreview;
GtkWidget * labelPreview;
GtkWidget * hboxPreviewFrame;
GtkWidget * framePreview;
GtkWidget * drawingareaPreview;
GtkWidget * hseparator4;
hboxPreview = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_widget_show (hboxPreview);
pSS->getValueUTF8(AP_STRING_ID_DLG_Para_LabelPreview,s);
UT_XML_cloneNoAmpersands(unixstr, s.utf8_str());
labelPreview = gtk_label_new (unixstr);
FREEP(unixstr);
gtk_widget_show (labelPreview);
gtk_box_pack_start (GTK_BOX (hboxPreview), labelPreview, FALSE, TRUE, 0);
gtk_label_set_justify (GTK_LABEL (labelPreview), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (labelPreview), 0, 0.5);
hseparator4 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_show (hseparator4);
gtk_box_pack_start (GTK_BOX (hboxPreview), hseparator4, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vboxContents), hboxPreview, TRUE, TRUE, 0);
hboxPreviewFrame = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_widget_show (hboxPreviewFrame);
framePreview = gtk_frame_new (NULL);
gtk_widget_show (framePreview);
gtk_box_pack_start (GTK_BOX (hboxPreviewFrame), framePreview, TRUE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vboxContents), hboxPreviewFrame, FALSE, TRUE, 0);
gtk_widget_set_size_request (framePreview, 400, 150);
gtk_frame_set_shadow_type (GTK_FRAME (framePreview), GTK_SHADOW_NONE);
drawingareaPreview = createDrawingArea ();
gtk_widget_show (drawingareaPreview);
gtk_container_add (GTK_CONTAINER (framePreview), drawingareaPreview);
#endif
// Update member variables with the important widgets that
// might need to be queried or altered later.
m_windowContents = vboxContents;
m_listAlignment = GTK_WIDGET(listAlignment);
// m_spinbuttonLeft_adj = spinbuttonLeft_adj;
m_spinbuttonLeft = spinbuttonLeft;
// m_spinbuttonRight_adj = spinbuttonRight_adj;
m_spinbuttonRight = spinbuttonRight;
m_listSpecial = GTK_WIDGET(listSpecial);
// m_spinbuttonBy_adj = spinbuttonBy_adj;
m_spinbuttonBy = spinbuttonBy;
// m_spinbuttonBefore_adj = spinbuttonBefore_adj;
m_spinbuttonBefore = spinbuttonBefore;
// m_spinbuttonAfter_adj = spinbuttonAfter_adj;
m_spinbuttonAfter = spinbuttonAfter;
m_listLineSpacing = GTK_WIDGET(listLineSpacing);
// m_spinbuttonAt_adj = spinbuttonAt_adj;
m_spinbuttonAt = spinbuttonAt;
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
m_drawingareaPreview = NULL;
#else
m_drawingareaPreview = drawingareaPreview;
#endif
m_checkbuttonWidowOrphan = checkbuttonWidowOrphan;
m_checkbuttonKeepLines = checkbuttonKeepLines;
m_checkbuttonPageBreak = checkbuttonPageBreak;
m_checkbuttonSuppress = checkbuttonSuppress;
m_checkbuttonHyphenate = checkbuttonHyphenate;
m_checkbuttonKeepNext = checkbuttonKeepNext;
m_checkbuttonDomDirection = checkbuttonDomDirection;
return vboxContents;
}
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;
}
GtkWidget * AP_UnixDialog_FormatFrame::_constructWindow(void)
{
GtkWidget * window;
const XAP_StringSet * pSS = XAP_App::getApp()->getStringSet();
// get the path where our UI file is located
std::string ui_path = static_cast<XAP_UnixApp*>(XAP_App::getApp())->getAbiSuiteAppUIDir() + "/ap_UnixDialog_FormatFrame.xml";
// load the dialog from the UI file
GtkBuilder* builder = gtk_builder_new();
gtk_builder_add_from_file(builder, ui_path.c_str(), NULL);
// Update our member variables with the important widgets that
// might need to be queried or altered later
window = GTK_WIDGET(gtk_builder_get_object(builder, "ap_UnixDialog_FormatFrame"));
m_wLineTop = GTK_WIDGET(gtk_builder_get_object(builder, "tbBorderTop"));
m_wLineLeft = GTK_WIDGET(gtk_builder_get_object(builder, "tbBorderLeft"));
m_wLineRight = GTK_WIDGET(gtk_builder_get_object(builder, "tbBorderRight"));
m_wLineBottom = GTK_WIDGET(gtk_builder_get_object(builder, "tbBorderBottom"));
// place some nice pixmaps on our border toggle buttons
label_button_with_abi_pixmap(m_wLineTop, "tb_LineTop_xpm");
label_button_with_abi_pixmap(m_wLineLeft, "tb_LineLeft_xpm");
label_button_with_abi_pixmap(m_wLineRight, "tb_LineRight_xpm");
label_button_with_abi_pixmap(m_wLineBottom, "tb_LineBottom_xpm");
m_wPreviewArea = GTK_WIDGET(gtk_builder_get_object(builder, "daPreview"));
// set the dialog title
ConstructWindowName();
abiDialogSetTitle(window, m_WindowName);
// disable double buffering on our preview
gtk_widget_set_double_buffered(m_wPreviewArea, FALSE);
// localize the strings in our dialog, and set tags for some widgets
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbBorder")), pSS, AP_STRING_ID_DLG_FormatFrame_Borders);
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbBorderColor")), pSS, AP_STRING_ID_DLG_FormatFrame_Color);
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbBorderThickness")), pSS, AP_STRING_ID_DLG_FormatTable_Thickness);
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbBackground")), pSS, AP_STRING_ID_DLG_FormatFrame_Background);
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbBackgroundColor")), pSS, AP_STRING_ID_DLG_FormatFrame_Color);
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbSetImageBackground")), pSS, AP_STRING_ID_DLG_FormatFrame_SetImageBackground);
// Radio buttons to position type of the Frame
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbPositionTo")), pSS, AP_STRING_ID_DLG_FormatFrame_PositionTo);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbSetToParagraph")), pSS, AP_STRING_ID_DLG_FormatFrame_SetToParagraph);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbSetToColumn")), pSS, AP_STRING_ID_DLG_FormatFrame_SetToColumn);
localizeButton(GTK_WIDGET(gtk_builder_get_object(builder, "rbSetToPage")), pSS, AP_STRING_ID_DLG_FormatFrame_SetToPage);
m_wPosParagraph = GTK_WIDGET(gtk_builder_get_object(builder, "rbSetToParagraph"));
m_wPosColumn = GTK_WIDGET(gtk_builder_get_object(builder, "rbSetToColumn"));
m_wPosPage = GTK_WIDGET(gtk_builder_get_object(builder, "rbSetToPage"));
// Button and label for text wrapping
m_wWrapButton = GTK_WIDGET(gtk_builder_get_object(builder, "btTextWrapState"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_wWrapButton),TRUE);
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbTextWrapState")), pSS, AP_STRING_ID_DLG_FormatFrame_TextWrapping);
// add the buttons for background image to the dialog.
m_wSelectImageButton = GTK_WIDGET(gtk_builder_get_object(builder, "btSelectImage"));
m_wNoImageButton = GTK_WIDGET(gtk_builder_get_object(builder, "btSetNoImage"));
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbSelectImage")), pSS, AP_STRING_ID_DLG_FormatFrame_SelectImage);
localizeLabel(GTK_WIDGET(gtk_builder_get_object(builder, "lbSetNoImage")), pSS, AP_STRING_ID_DLG_FormatFrame_NoImageBackground);
localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbPreview")), pSS, AP_STRING_ID_DLG_FormatFrame_Preview);
m_wBorderColorButton = GTK_WIDGET(gtk_builder_get_object(builder, "cbtBorderColorButton"));
m_wBackgroundColorButton = GTK_WIDGET(gtk_builder_get_object(builder, "cbtBackgroundColorButton"));
//
// Now the Border Thickness Option menu
//
m_wBorderThickness = GTK_WIDGET(gtk_builder_get_object(builder, "omBorderThickness"));
GtkComboBox *combo = GTK_COMBO_BOX(m_wBorderThickness);
XAP_makeGtkComboBoxText(combo, G_TYPE_NONE);
// TODO WTF is this hardcoded.
gtk_combo_box_append_text(combo, "1/2 pt");
gtk_combo_box_append_text(combo, "3/4 pt");
gtk_combo_box_append_text(combo, "1 pt");
gtk_combo_box_append_text(combo, "1 1/2 pt");
gtk_combo_box_append_text(combo, "2 1/4 pt");
gtk_combo_box_append_text(combo, "3 pt");
gtk_combo_box_append_text(combo, "4 1/2 pt");
gtk_combo_box_append_text(combo, "6 pt");
gtk_combo_box_set_active(combo, 0);
// add the apply and ok buttons to the dialog
m_wCloseButton = GTK_WIDGET(gtk_builder_get_object(builder, "btClose"));
m_wApplyButton = GTK_WIDGET(gtk_builder_get_object(builder, "btApply"));
g_object_unref(G_OBJECT(builder));
return window;
}
GtkWidget * AP_UnixDialog_PageSetup::_constructWindow (void)
{
// get the path where our UI file is located
std::string ui_path = static_cast<XAP_UnixApp*>(XAP_App::getApp())->getAbiSuiteAppUIDir() + "/ap_UnixDialog_PageSetup.xml";
// load the dialog from the UI file
m_pBuilder = gtk_builder_new();
gtk_builder_add_from_file(m_pBuilder, ui_path.c_str(), NULL);
const XAP_StringSet * pSS = m_pApp->getStringSet ();
GList *glist;
GtkLabel *orientation;
m_window = _getWidget("ap_UnixDialog_PageSetup");
m_wHelp = _getWidget("wHelp");
m_comboPageSize = _getWidget("comboPageSize");
m_entryPageWidth = _getWidget("wWidthSpin");
m_entryPageHeight = _getWidget("wHeightSpin");
m_optionPageUnits = _getWidget("optionPageUnits");
m_radioPagePortrait = _getWidget("rbPortrait");
m_radioPageLandscape = _getWidget("rbLandscape");
m_spinPageScale = _getWidget("wPageScale");
m_optionMarginUnits = _getWidget("optionMarginUnits");
m_spinMarginTop = _getWidget("wTopSpin");
m_spinMarginBottom = _getWidget("wBottomSpin");
m_spinMarginLeft = _getWidget("wLeftSpin");
m_spinMarginRight = _getWidget("wRightSpin");
m_spinMarginHeader = _getWidget("wHeaderSpin");
m_spinMarginFooter = _getWidget("wFooterSpin");
m_MarginHbox = _getWidget("hbox15");
m_PageHbox = _getWidget("hbox16");
/* required for translations */
gtk_label_set_text (GTK_LABEL (_getWidget("lbPage")), _(AP, DLG_PageSetup_Page));
gtk_label_set_text (GTK_LABEL (_getWidget("lbMargin")), _(AP, DLG_PageSetup_Margin));
Markup (_getWidget("lbPaper"), pSS, _(AP, DLG_PageSetup_Paper));
gtk_label_set_text (GTK_LABEL (_getWidget("lbPaperSize")), _(AP, DLG_PageSetup_Paper_Size));
gtk_label_set_text (GTK_LABEL (_getWidget("lbPageUnits")), _(AP, DLG_PageSetup_Units));
gtk_label_set_text (GTK_LABEL (_getWidget("lbWidth")), _(AP, DLG_PageSetup_Width));
gtk_label_set_text (GTK_LABEL (_getWidget("lbHeight")), _(AP, DLG_PageSetup_Height));
Markup (_getWidget("lbOrientation"), pSS, _(AP, DLG_PageSetup_Orient));
/* radio button labels */
glist = gtk_container_get_children (GTK_CONTAINER (m_radioPagePortrait));
orientation = GTK_LABEL (g_list_nth_data (glist, 0));
gtk_label_set_text (GTK_LABEL (orientation), _(AP, DLG_PageSetup_Portrait));
glist = gtk_container_get_children (GTK_CONTAINER (m_radioPageLandscape));
orientation = GTK_LABEL (g_list_nth_data (glist, 0));
gtk_label_set_text (GTK_LABEL (orientation), _(AP, DLG_PageSetup_Landscape));
Markup (_getWidget("lbScale"), pSS, _(AP, DLG_PageSetup_Scale));
gtk_label_set_text (GTK_LABEL (_getWidget("lbAdjust")), _(AP, DLG_PageSetup_Adjust));
gtk_label_set_text (GTK_LABEL (_getWidget("lbPercentNormalSize")), _(AP, DLG_PageSetup_Percent));
gtk_label_set_text (GTK_LABEL (_getWidget("lbMarginUnits")), _(AP, DLG_PageSetup_Units));
gtk_label_set_text (GTK_LABEL (_getWidget("lbTop")), _(AP, DLG_PageSetup_Top));
gtk_label_set_text (GTK_LABEL (_getWidget("lbRight")), _(AP, DLG_PageSetup_Right));
gtk_label_set_text (GTK_LABEL (_getWidget("lbLeft")), _(AP, DLG_PageSetup_Left));
gtk_label_set_text (GTK_LABEL (_getWidget("lbBottom")), _(AP, DLG_PageSetup_Bottom));
gtk_label_set_text (GTK_LABEL (_getWidget("lbHeader")), _(AP, DLG_PageSetup_Header));
gtk_label_set_text (GTK_LABEL (_getWidget("lbFooter")), _(AP, DLG_PageSetup_Footer));
/* end translation req */
/* setup page width and height */
if (!getPageOrientation () == PORTRAIT)
{
m_PageSize.setLandscape();
}
gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_entryPageWidth), m_PageSize.Width (getPageUnits ()));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_entryPageHeight), m_PageSize.Height (getPageUnits ()));
/* setup margin numbers */
gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginTop), getMarginTop ());
gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginBottom), getMarginBottom ());
gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginLeft), getMarginLeft ());
gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginRight), getMarginRight ());
gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginHeader), getMarginHeader ());
gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinMarginFooter), getMarginFooter ());
/* setup scale number */
gtk_spin_button_set_value (GTK_SPIN_BUTTON (m_spinPageScale), static_cast<float>(getPageScale ()));
// fill the combobox all of our supported page sizes
GtkListStore* pagesize_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
GtkTreeIter pagesize_iter;
for (UT_uint32 i = fp_PageSize::_first_predefined_pagesize_; i < fp_PageSize::_last_predefined_pagesize_dont_use_; i++)
{
gtk_list_store_append(pagesize_store, &pagesize_iter);
gtk_list_store_set(pagesize_store, &pagesize_iter,
0, fp_PageSize::PredefinedToName ((fp_PageSize::Predefined)i),
1, this,
-1);
}
gtk_combo_box_set_model(GTK_COMBO_BOX(m_comboPageSize), GTK_TREE_MODEL(pagesize_store));
m_iComboPageSizeListID = g_signal_connect(G_OBJECT(m_comboPageSize),
"changed",
G_CALLBACK(s_page_size_changed),
static_cast<gpointer>(this));
/* setup page units menu */
GtkComboBox *combo = GTK_COMBO_BOX(m_optionPageUnits);
XAP_makeGtkComboBoxText(combo, G_TYPE_INT);
XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_inch), DIM_IN);
XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_cm), DIM_CM);
XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_mm), DIM_MM);
XAP_comboBoxSetActiveFromIntCol(combo, 1, getPageUnits ());
/* setup margin units menu */
combo = GTK_COMBO_BOX(m_optionMarginUnits);
XAP_makeGtkComboBoxText(combo, G_TYPE_INT);
XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_inch), DIM_IN);
XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_cm), DIM_CM);
XAP_appendComboBoxTextAndInt(combo, _(XAP, DLG_Unit_mm), DIM_MM);
last_margin_unit = getMarginUnits ();
XAP_comboBoxSetActiveFromIntCol(combo, 1, last_margin_unit);
/* add margin XPM image to the margin window */
customPreview = create_pixmap (m_MarginHbox, margin_xpm);
gtk_widget_show (customPreview);
gtk_box_pack_start (GTK_BOX (m_MarginHbox), customPreview, FALSE, FALSE, 0);
/* add correct page XPM image to the page window */
if (getPageOrientation () == PORTRAIT)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (m_radioPagePortrait), TRUE);
customPreview = create_pixmap (m_PageHbox, orient_vertical_xpm);
gtk_widget_show (customPreview);
gtk_box_pack_start (GTK_BOX (m_PageHbox), customPreview, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (m_PageHbox), customPreview, 0);
}
else
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (m_radioPageLandscape), TRUE);
customPreview = create_pixmap (m_PageHbox, orient_horizontal_xpm);
gtk_widget_show (customPreview);
gtk_box_pack_start (GTK_BOX (m_PageHbox), customPreview, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (m_PageHbox), customPreview, 0);
}
abiAddStockButton(GTK_DIALOG(m_window), GTK_STOCK_CANCEL, BUTTON_CANCEL);
abiAddStockButton(GTK_DIALOG(m_window), GTK_STOCK_OK, BUTTON_OK);
_connectSignals ();
return m_window;
}