void AP_UnixDialog_Paragraph::_populateWindowData(void)
{
// alignment option menu
UT_ASSERT(m_listAlignment);
XAP_comboBoxSetActiveFromIntCol(GTK_COMBO_BOX(m_listAlignment), 1,
(gint) _getMenuItemValue(id_MENU_ALIGNMENT));
// indent and paragraph margins
UT_ASSERT(m_spinbuttonLeft);
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonLeft),
(const gchar *) _getSpinItemValue(id_SPIN_LEFT_INDENT));
UT_ASSERT(m_spinbuttonRight);
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonRight),
(const gchar *) _getSpinItemValue(id_SPIN_RIGHT_INDENT));
UT_ASSERT(m_spinbuttonBy);
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonBy),
(const gchar *) _getSpinItemValue(id_SPIN_SPECIAL_INDENT));
UT_ASSERT(m_listSpecial);
XAP_comboBoxSetActiveFromIntCol(GTK_COMBO_BOX(m_listSpecial), 1,
(gint) _getMenuItemValue(id_MENU_SPECIAL_INDENT));
// spacing
UT_ASSERT(m_spinbuttonLeft);
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonBefore),
(const gchar *) _getSpinItemValue(id_SPIN_BEFORE_SPACING));
UT_ASSERT(m_spinbuttonRight);
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonAfter),
(const gchar *) _getSpinItemValue(id_SPIN_AFTER_SPACING));
UT_ASSERT(m_spinbuttonAt);
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonAt),
(const gchar *) _getSpinItemValue(id_SPIN_SPECIAL_SPACING));
UT_ASSERT(m_listLineSpacing);
XAP_comboBoxSetActiveFromIntCol(GTK_COMBO_BOX(m_listLineSpacing), 1,
(gint) _getMenuItemValue(id_MENU_SPECIAL_SPACING));
// set the check boxes
// TODO : handle tri-state boxes !!!
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonWidowOrphan)),
(_getCheckItemValue(id_CHECK_WIDOW_ORPHAN) == check_TRUE));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonKeepLines)),
(_getCheckItemValue(id_CHECK_KEEP_LINES) == check_TRUE));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonPageBreak)),
(_getCheckItemValue(id_CHECK_PAGE_BREAK) == check_TRUE));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonSuppress)),
(_getCheckItemValue(id_CHECK_SUPPRESS) == check_TRUE));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonHyphenate)),
(_getCheckItemValue(id_CHECK_NO_HYPHENATE) == check_TRUE));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonKeepNext)),
(_getCheckItemValue(id_CHECK_KEEP_NEXT) == check_TRUE));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_CHECK_BUTTON(m_checkbuttonDomDirection)),
(_getCheckItemValue(id_CHECK_DOMDIRECTION) == check_TRUE));
}
void AP_Dialog_Paragraph::_setSpinItemValue(tControl item, const gchar * value,
tOperation op /* = op_UICHANGE */)
{
UT_return_if_fail (item <= m_vecProperties.getItemCount() && value);
sControlData * pItem = _getPropertyItem (item);
UT_return_if_fail (pItem);
// some spinbuttons have special data requirements
switch(item)
{
case id_SPIN_LEFT_INDENT:
case id_SPIN_RIGHT_INDENT:
case id_SPIN_SPECIAL_INDENT:
pItem->setData (reinterpret_cast<const gchar *>(UT_reformatDimensionString (m_dim, value)));
break;
case id_SPIN_BEFORE_SPACING:
case id_SPIN_AFTER_SPACING:
{
/* NOTE : line spacing can't be negative, so take absolute value:
*/
const char * abs_value = UT_reformatDimensionString (DIM_PT, _makeAbsolute (value));
pItem->setData (reinterpret_cast<const gchar *>(abs_value));
}
break;
case id_SPIN_SPECIAL_SPACING:
if (_getMenuItemValue (id_MENU_SPECIAL_SPACING) == spacing_MULTIPLE)
{
const char * abs_value = UT_reformatDimensionString (DIM_none, _makeAbsolute (value), ".2");
pItem->setData (reinterpret_cast<const gchar *>(abs_value));
}
else
{
const char * abs_value = UT_reformatDimensionString (DIM_PT, _makeAbsolute (value));
pItem->setData (reinterpret_cast<const gchar *>(abs_value));
}
break;
default:
/* all others get a simple string copy to the static member
*/
pItem->setData (value);
}
if ((op == op_UICHANGE) || (op == op_SYNC))
pItem->changed (true);
// for UI-driven changes, may need to sync other controls
if (op == op_UICHANGE)
_syncControls(item);
}
void AP_Dialog_Paragraph::_syncControls(tControl changed, bool /*bAll = false */)
{
if(changed == id_SPIN_LEFT_INDENT)
{
// need to check the limits
// cannot go past left page margin.
// TODO : is there a minimum text width?
double leftPageMargin = UT_convertToDimension(m_pageLeftMargin, m_dim);
double rightIndent = UT_convertToDimension(_getSpinItemValue(id_SPIN_RIGHT_INDENT), m_dim);
if(-UT_convertToDimension(_getSpinItemValue(id_SPIN_LEFT_INDENT), m_dim) >
leftPageMargin)
{
_setSpinItemValue(id_SPIN_LEFT_INDENT,
(const gchar *)UT_formatDimensionString(m_dim, -leftPageMargin),
op_SYNC);
}
// nor past pagesize - rightIndent on right.
if(UT_convertDimensionless(_getSpinItemValue(id_SPIN_LEFT_INDENT)) >
UT_convertInchesToDimension(m_iMaxWidth, m_dim) - rightIndent)
{
_setSpinItemValue(id_SPIN_LEFT_INDENT,
(const gchar *)UT_convertInchesToDimensionString(m_dim, m_iMaxWidth - rightIndent),
op_SYNC);
}
}
if(changed == id_SPIN_RIGHT_INDENT)
{
// need to check the limits
// cannot go past right page margin.
double rightPageMargin = UT_convertToDimension(m_pageRightMargin, m_dim);
double leftIndent = UT_convertToDimension(_getSpinItemValue(id_SPIN_LEFT_INDENT), m_dim);
if(-UT_convertToDimension(_getSpinItemValue(id_SPIN_RIGHT_INDENT), m_dim) >
rightPageMargin)
{
_setSpinItemValue(id_SPIN_RIGHT_INDENT,
(const gchar *)UT_formatDimensionString(m_dim, -rightPageMargin),
op_SYNC);
}
// nor can we force text left past pagesize, minus left margin
if(UT_convertDimensionless(_getSpinItemValue(id_SPIN_RIGHT_INDENT)) >
UT_convertInchesToDimension(m_iMaxWidth, m_dim) - leftIndent)
{
_setSpinItemValue(id_SPIN_RIGHT_INDENT,
(const gchar *)UT_convertInchesToDimensionString(m_dim, m_iMaxWidth - leftIndent),
op_SYNC);
}
}
if (changed == id_MENU_SPECIAL_INDENT || changed == id_SPIN_SPECIAL_INDENT)
{
double dDefault = 0.0;
bool bDefault = true;
double sign = -1.0;
if (_getMenuItemValue(id_MENU_SPECIAL_INDENT) == indent_FIRSTLINE)
sign = +1.0;
if (changed == id_MENU_SPECIAL_INDENT)
{
switch(_getMenuItemValue(id_MENU_SPECIAL_INDENT))
{
case indent_NONE:
dDefault = 0.0;
break;
case indent_FIRSTLINE:
case indent_HANGING:
// only change to default if existing value is zero
dDefault = UT_convertDimensionless(_getSpinItemValue(id_SPIN_SPECIAL_INDENT));
if (dDefault == 0)
{
bDefault = false;
}
else
{
dDefault = 0.5;
}
break;
default:
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
break;
}
if (bDefault)
{
if (m_dim != DIM_IN)
dDefault = UT_convertInchesToDimension(dDefault, m_dim);
const gchar* szNew = UT_convertInchesToDimensionString(m_dim, dDefault, ".1");
_setSpinItemValue(id_SPIN_SPECIAL_INDENT, szNew, op_SYNC);
}
}
else /* (changed == id_SPIN_SPECIAL_INDENT) */
{
switch(_getMenuItemValue(id_MENU_SPECIAL_INDENT))
{
case indent_NONE:
_setMenuItemValue(id_MENU_SPECIAL_INDENT, indent_FIRSTLINE, op_SYNC);
break;
default:
break;
}
}
// if spin contains a negative number, we flip the direction of the indent.
double val = UT_convertDimensionless(_getSpinItemValue(id_SPIN_SPECIAL_INDENT));
if (val < 0)
{
sign = -sign;
// sometimes this appears to have no effect. why?
if (_getMenuItemValue(id_MENU_SPECIAL_INDENT) == indent_FIRSTLINE)
_setMenuItemValue(id_MENU_SPECIAL_INDENT, indent_HANGING, op_SYNC);
else if (_getMenuItemValue(id_MENU_SPECIAL_INDENT) == indent_HANGING)
_setMenuItemValue(id_MENU_SPECIAL_INDENT, indent_FIRSTLINE, op_SYNC);
const gchar* szNew = UT_convertInchesToDimensionString(m_dim, -val, ".1");
_setSpinItemValue(id_SPIN_SPECIAL_INDENT, szNew, op_SYNC);
}
// sanity check.
double leftIndent =
UT_convertToDimension(_getSpinItemValue(id_SPIN_LEFT_INDENT), m_dim);
double effectiveLeftMargin = leftIndent + (UT_convertToDimension
(_getSpinItemValue(id_SPIN_SPECIAL_INDENT), m_dim) * sign);
double leftPageMargin = UT_convertToDimension(m_pageLeftMargin, m_dim);
double rightIndent = UT_convertToDimension(_getSpinItemValue(id_SPIN_RIGHT_INDENT), m_dim);
if(-effectiveLeftMargin > leftPageMargin)
{
_setSpinItemValue(id_SPIN_SPECIAL_INDENT,
(const gchar *)UT_formatDimensionString(m_dim, -leftPageMargin),
op_SYNC);
}
if(effectiveLeftMargin >
UT_convertInchesToDimension(m_iMaxWidth, m_dim) - rightIndent)
{
_setSpinItemValue(id_SPIN_SPECIAL_INDENT,
(const gchar *)UT_convertInchesToDimensionString(m_dim, m_iMaxWidth - rightIndent),
op_SYNC);
}
}
if (changed == id_SPIN_SPECIAL_SPACING)
{
switch(_getMenuItemValue(id_MENU_SPECIAL_SPACING))
{
case spacing_SINGLE:
case spacing_ONEANDHALF:
case spacing_DOUBLE:
_setMenuItemValue(id_MENU_SPECIAL_SPACING, spacing_MULTIPLE, op_SYNC);
break;
default:
break;
}
}
if (changed == id_MENU_SPECIAL_SPACING)
{
UT_Dimension dimOld = UT_determineDimension(_getSpinItemValue(id_SPIN_SPECIAL_SPACING), DIM_none);
switch(_getMenuItemValue(id_MENU_SPECIAL_SPACING))
{
case spacing_SINGLE:
_setSpinItemValue(id_SPIN_SPECIAL_SPACING, "1.0", op_SYNC);
break;
case spacing_ONEANDHALF:
_setSpinItemValue(id_SPIN_SPECIAL_SPACING, "1.5", op_SYNC);
break;
case spacing_DOUBLE:
_setSpinItemValue(id_SPIN_SPECIAL_SPACING, "2.0", op_SYNC);
break;
case spacing_ATLEAST:
case spacing_EXACTLY:
// only change to default if not dimensioned
if (dimOld == DIM_none)
_setSpinItemValue(id_SPIN_SPECIAL_SPACING, "12pt", op_SYNC);
break;
case spacing_MULTIPLE:
// only change to default if dimensioned
if (dimOld != DIM_none)
_setSpinItemValue(id_SPIN_SPECIAL_SPACING, "1.0", op_SYNC);
break;
default:
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
break;
}
}
// the preview needs to suck in the changed data (to cache it
// for subsequent draws)
UT_BidiCharType iDir;
if(_getCheckItemValue(id_CHECK_DOMDIRECTION) == check_TRUE)
iDir = UT_BIDI_RTL;
else if(_getCheckItemValue(id_CHECK_DOMDIRECTION) == check_FALSE)
iDir = UT_BIDI_LTR;
else
{
// nothing given -- default to LTR
UT_DEBUGMSG(("AP_Dialog_Paragraph::_syncControls: no value of dom-dir,"
" defaulting to LTR\n"));
iDir = UT_BIDI_LTR;
}
m_paragraphPreview->setFormat(m_pageLeftMargin,
m_pageRightMargin,
(AP_Dialog_Paragraph::tAlignState) _getMenuItemValue(id_MENU_ALIGNMENT),
_getSpinItemValue(id_SPIN_SPECIAL_INDENT),
(AP_Dialog_Paragraph::tIndentState) _getMenuItemValue(id_MENU_SPECIAL_INDENT),
_getSpinItemValue(id_SPIN_LEFT_INDENT),
_getSpinItemValue(id_SPIN_RIGHT_INDENT),
_getSpinItemValue(id_SPIN_BEFORE_SPACING),
_getSpinItemValue(id_SPIN_AFTER_SPACING),
_getSpinItemValue(id_SPIN_SPECIAL_SPACING),
(AP_Dialog_Paragraph::tSpacingState) _getMenuItemValue(id_MENU_SPECIAL_SPACING),
iDir);
m_paragraphPreview->queueDraw();
}
void AP_Dialog_Paragraph::_doSpin(tControl edit, UT_sint32 amt)
{
UT_ASSERT_HARMLESS(amt); // zero makes no sense
// get current value from member
const gchar* szOld = _getSpinItemValue(edit);
double d = UT_convertDimensionless(szOld);
// figure out which dimension and units to spin in
UT_Dimension dimSpin = m_dim;
double dSpinUnit = SPIN_INCR_PT;
double dMin = 0.0;
bool bMin = false;
switch (edit)
{
case id_SPIN_SPECIAL_INDENT:
dMin = 0.0;
bMin = true;
// fall through
case id_SPIN_LEFT_INDENT:
case id_SPIN_RIGHT_INDENT:
dimSpin = m_dim;
switch (dimSpin)
{
case DIM_IN: dSpinUnit = SPIN_INCR_IN; break;
case DIM_CM: dSpinUnit = SPIN_INCR_CM; break;
case DIM_PI: dSpinUnit = SPIN_INCR_PI; break;
case DIM_PT: dSpinUnit = SPIN_INCR_PT; break;
default:
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
break;
}
break;
case id_SPIN_BEFORE_SPACING:
case id_SPIN_AFTER_SPACING:
dimSpin = DIM_PT;
dSpinUnit = 6.0;
dMin = 0.0;
bMin = true;
break;
case id_SPIN_SPECIAL_SPACING:
switch(_getMenuItemValue(id_MENU_SPECIAL_SPACING))
{
case spacing_SINGLE:
case spacing_ONEANDHALF:
case spacing_DOUBLE:
_setMenuItemValue(id_MENU_SPECIAL_SPACING, spacing_MULTIPLE);
// fall through
case spacing_MULTIPLE:
dimSpin = DIM_none;
dSpinUnit = 0.1;
dMin = 0.5;
bMin = true;
break;
case spacing_EXACTLY:
dMin = 1;
// fall through
case spacing_ATLEAST:
dimSpin = DIM_PT;
dSpinUnit = SPIN_INCR_PT;
bMin = true;
break;
default:
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
break;
}
break;
default:
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
break;
}
// figure out spin precision, too
const char * szPrecision = ".1";
if ((dimSpin == DIM_PT) ||
(dimSpin == DIM_PI))
szPrecision = ".0";
// if needed, switch unit systems and round off
UT_Dimension dimOld = UT_determineDimension(szOld, dimSpin);
if (dimOld != dimSpin)
{
double dInches = UT_convertToInches(szOld);
d = UT_convertInchesToDimension(dInches, dimSpin);
}
// value is now in desired units, so change it
d += (dSpinUnit * amt);
if (bMin)
{
// some spinners clamp at bottom of range
if (d < dMin)
d = dMin;
}
const gchar* szNew = UT_formatDimensionString(dimSpin, d, szPrecision);
_setSpinItemValue(edit, szNew);
}
bool AP_Dialog_Paragraph::getDialogData(const gchar **& pProps)
{
UT_Vector v;
struct propPair
{
gchar * prop;
gchar * val;
};
propPair * p;
// only do this if the control has a proper value
if (_wasChanged(id_MENU_ALIGNMENT) && _getMenuItemValue(id_MENU_ALIGNMENT))
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("text-align");
switch (_getMenuItemValue(id_MENU_ALIGNMENT))
{
case align_LEFT:
p->val = g_strdup("left");
break;
case align_CENTERED:
p->val = g_strdup("center");
break;
case align_RIGHT:
p->val = g_strdup("right");
break;
case align_JUSTIFIED:
p->val = g_strdup("justify");
break;
default:
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
v.addItem(p);
}
if (_wasChanged(id_CHECK_DOMDIRECTION))
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("dom-dir");
if (_getCheckItemValue(id_CHECK_DOMDIRECTION) == check_TRUE)
p->val = g_strdup("rtl");
else
p->val = g_strdup("ltr");
v.addItem(p);
}
if (_wasChanged(id_SPIN_LEFT_INDENT))
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("margin-left");
p->val = g_strdup(_getSpinItemValue(id_SPIN_LEFT_INDENT));
v.addItem(p);
}
if (_wasChanged(id_SPIN_RIGHT_INDENT))
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("margin-right");
p->val = g_strdup(_getSpinItemValue(id_SPIN_RIGHT_INDENT));
v.addItem(p);
}
// TODO : The logic here might not be bulletproof. If the user triggers
// TODO : a change in the TYPE of special indent (hanging, first line,
// TODO : none), we will always save what's in the box as a property.
// TODO : One could make it smarter with a stronger contract with
// TODO : the platform interfaces.
if (_getMenuItemValue(id_MENU_SPECIAL_INDENT) &&
(_wasChanged(id_MENU_SPECIAL_INDENT) || _wasChanged(id_SPIN_SPECIAL_INDENT)))
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("text-indent");
tIndentState i = (tIndentState) _getMenuItemValue(id_MENU_SPECIAL_INDENT);
if (i == indent_NONE)
p->val = g_strdup(UT_convertInchesToDimensionString(m_dim, 0));
else if (i == indent_FIRSTLINE)
p->val = g_strdup(_getSpinItemValue(id_SPIN_SPECIAL_INDENT));
else if (i == indent_HANGING)
{
// we have to flip the sign for "hanging" indents to a negative quantity for
// storage in the document as a text-indent
// get with no dimension
UT_Dimension dim = UT_determineDimension(_getSpinItemValue(id_SPIN_SPECIAL_INDENT));
double val = UT_convertDimensionless(_getSpinItemValue(id_SPIN_SPECIAL_INDENT));
// Convert to inches
val = UT_convertDimToInches(val, dim);
// flip sign
val = val * (double) -1;
// store the reconstructed
p->val = g_strdup(UT_convertInchesToDimensionString(dim, val));
}
v.addItem(p);
}
if (_wasChanged(id_SPIN_BEFORE_SPACING))
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("margin-top");
p->val = g_strdup(_getSpinItemValue(id_SPIN_BEFORE_SPACING));
v.addItem(p);
}
if (_wasChanged(id_SPIN_AFTER_SPACING))
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("margin-bottom");
p->val = g_strdup(_getSpinItemValue(id_SPIN_AFTER_SPACING));
v.addItem(p);
}
// TODO : The logic here might not be bulletproof. If the user triggers
// TODO : a change in the TYPE of special indent (single, double, etc.)
// TODO : we will always save what's in the box as a property.
// TODO : One could make it smarter with a stronger contract with
// TODO : the platform interfaces.
if(_getMenuItemValue(id_MENU_SPECIAL_SPACING) &&
(_wasChanged(id_MENU_SPECIAL_SPACING) || _wasChanged(id_SPIN_SPECIAL_SPACING)))
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("line-height");
// normal spacings (single, 1.5, double) are just simple numbers.
// "at least" needs a "+" at the end of the number (no units).
// "exactly" simply has units.
// "multiple" has no units.
gchar * pTmp = NULL;
const gchar * pString = _getSpinItemValue(id_SPIN_SPECIAL_SPACING);
UT_uint32 nSize = 0;
switch(_getMenuItemValue(id_MENU_SPECIAL_SPACING))
{
case spacing_SINGLE:
p->val = g_strdup("1.0");
break;
case spacing_ONEANDHALF:
p->val = g_strdup("1.5");
break;
case spacing_DOUBLE:
p->val = g_strdup("2.0");
break;
case spacing_ATLEAST:
nSize = strlen(pString);
pTmp = (gchar *) UT_calloc(nSize + 2, sizeof(gchar));
UT_return_val_if_fail (pTmp, false);
strncpy(pTmp, pString, nSize);
// stick a '+' at the end
pTmp[nSize] = '+';
p->val = g_strdup(pTmp);
FREEP(pTmp);
break;
case spacing_EXACTLY:
// fallthrough
case spacing_MULTIPLE:
// both these cases either do or don't have units associated with them.
// the platform dialog code takes care of that.
p->val = g_strdup(pString);
break;
default:
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
v.addItem(p);
}
// NOTE : "orphans" and "widows" hold a number specifying the number
// NOTE : of lines to consider an orphaned or widowed piece of text.
// NOTE : If they're both 0 they're off. If either is greater than
// NOTE : 0, then some form of control is in effect. If the property
// NOTE : is not set, they're indeterminate.
if (_wasChanged(id_CHECK_WIDOW_ORPHAN))
{
// TODO : fix this! we stomp on both properties (setting them
// TODO : to "2"s or "0"s) if the one check box was ever
// TODO : changed
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("orphans");
if (_getCheckItemValue(id_CHECK_WIDOW_ORPHAN) == check_TRUE)
p->val = g_strdup("2");
else
p->val = g_strdup("0");
v.addItem(p);
}
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("widows");
if (_getCheckItemValue(id_CHECK_WIDOW_ORPHAN) == check_TRUE)
p->val = g_strdup("2");
else
p->val = g_strdup("0");
v.addItem(p);
}
}
if (_wasChanged(id_CHECK_KEEP_LINES))
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("keep-together");
if (_getCheckItemValue(id_CHECK_KEEP_LINES) == check_TRUE)
p->val = g_strdup("yes");
else
p->val = g_strdup("no");
v.addItem(p);
}
if (_wasChanged(id_CHECK_KEEP_NEXT))
{
ALLOC_PROP_PAIR(p);
p->prop = g_strdup("keep-with-next");
if (_getCheckItemValue(id_CHECK_KEEP_NEXT) == check_TRUE)
p->val = g_strdup("yes");
else
p->val = g_strdup("no");
v.addItem(p);
}
// TODO : add these to PP_Property (pp_Property.cpp) !!!
/*
m_pageBreakBefore;
m_suppressLineNumbers;
m_noHyphenate;
*/
// export everything in the array
UT_uint32 count = v.getItemCount()*2 + 1;
const gchar ** newprops = (const gchar **) UT_calloc(count, sizeof(gchar *));
if (!newprops)
return false;
const gchar ** newitem = newprops;
UT_uint32 i = v.getItemCount();
while (i > 0)
{
p = (propPair *) v.getNthItem(i-1);
i--;
newitem[0] = p->prop;
newitem[1] = p->val;
newitem += 2;
}
// DO purge the vector's CONTENTS, which are just propPair structs
UT_VECTOR_FREEALL(propPair *, v);
// DO NOT purge the propPair's CONTENTS, because they will be pointed to
// by the pointers we just copied into memory typed (gchar **)
pProps = newprops;
return true;
}
void AP_UnixDialog_Paragraph::_syncControls(tControl changed, bool bAll /* = false */)
{
// let parent sync any member variables first
AP_Dialog_Paragraph::_syncControls(changed, bAll);
// sync the display
// 1. link the "hanging indent by" combo and spinner
if (bAll || (changed == id_SPIN_SPECIAL_INDENT))
{
// typing in the control can change the associated combo
if (_getMenuItemValue(id_MENU_SPECIAL_INDENT) == indent_FIRSTLINE)
{
XAP_comboBoxSetActiveFromIntCol(GTK_COMBO_BOX(m_listSpecial),1,
(gint) _getMenuItemValue(id_MENU_SPECIAL_INDENT));
}
}
if (bAll || (changed == id_MENU_SPECIAL_INDENT))
{
switch(_getMenuItemValue(id_MENU_SPECIAL_INDENT))
{
case indent_NONE:
// clear the spin control
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonBy), "");
gtk_widget_set_sensitive(m_spinbuttonBy, FALSE);
break;
default:
// set the spin control
gtk_widget_set_sensitive(m_spinbuttonBy, TRUE);
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonBy), _getSpinItemValue(id_SPIN_SPECIAL_INDENT));
break;
}
}
// 2. link the "line spacing at" combo and spinner
if (bAll || (changed == id_SPIN_SPECIAL_SPACING))
{
// typing in the control can change the associated combo
if (_getMenuItemValue(id_MENU_SPECIAL_SPACING) == spacing_MULTIPLE)
{
XAP_comboBoxSetActiveFromIntCol(GTK_COMBO_BOX(m_listLineSpacing),1,
(gint) _getMenuItemValue(id_MENU_SPECIAL_SPACING));
}
}
if (bAll || (changed == id_MENU_SPECIAL_SPACING))
{
switch(_getMenuItemValue(id_MENU_SPECIAL_SPACING))
{
case spacing_SINGLE:
case spacing_ONEANDHALF:
case spacing_DOUBLE:
// clear the spin control
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonAt), "");
gtk_widget_set_sensitive(m_spinbuttonAt, FALSE);
break;
default:
// set the spin control
gtk_widget_set_sensitive(m_spinbuttonAt, TRUE);
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonAt), _getSpinItemValue(id_SPIN_SPECIAL_SPACING));
break;
}
}
// 3. move results of _doSpin() back to screen
if (!bAll)
{
// spin controls only sync when spun
switch (changed)
{
case id_SPIN_LEFT_INDENT:
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonLeft), _getSpinItemValue(id_SPIN_LEFT_INDENT));
break;
case id_SPIN_RIGHT_INDENT:
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonRight), _getSpinItemValue(id_SPIN_RIGHT_INDENT));
break;
case id_SPIN_SPECIAL_INDENT:
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonBy), _getSpinItemValue(id_SPIN_SPECIAL_INDENT));
break;
case id_SPIN_BEFORE_SPACING:
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonBefore), _getSpinItemValue(id_SPIN_BEFORE_SPACING));
break;
case id_SPIN_AFTER_SPACING:
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonAfter), _getSpinItemValue(id_SPIN_AFTER_SPACING));
break;
case id_SPIN_SPECIAL_SPACING:
gtk_entry_set_text(GTK_ENTRY(m_spinbuttonAt), _getSpinItemValue(id_SPIN_SPECIAL_SPACING));
break;
default:
break;
}
}
}
void AP_Win32Dialog_Paragraph::_syncControls(tControl changed, bool bAll /* = false */)
{
// let parent sync any member variables first
AP_Dialog_Paragraph::_syncControls(changed, bAll);
// sync the display
// 1. link the "hanging indent by" combo and spinner
if (bAll || (changed == id_SPIN_SPECIAL_INDENT))
{
// typing in the control can change the associated combo
if (_getMenuItemValue(id_MENU_SPECIAL_INDENT) == indent_FIRSTLINE)
{
HWND h = GetDlgItem(m_hwndSpacing, AP_RID_DIALOG_PARA_COMBO_HANG);
SendMessageW(h, CB_SETCURSEL, (WPARAM) _getMenuItemValue(id_MENU_SPECIAL_INDENT), 0);
}
}
if (bAll || (changed == id_MENU_SPECIAL_INDENT))
{
switch(_getMenuItemValue(id_MENU_SPECIAL_INDENT))
{
case indent_NONE:
// clear the spin control
SetDlgItemText(m_hwndSpacing, AP_RID_DIALOG_PARA_EDIT_BY, NULL);
break;
default:
// set the spin control
SetDlgItemText(m_hwndSpacing, AP_RID_DIALOG_PARA_EDIT_BY, _getSpinItemValue(id_SPIN_SPECIAL_INDENT));
break;
}
}
// 2. link the "line spacing at" combo and spinner
if (bAll || (changed == id_SPIN_SPECIAL_SPACING))
{
// typing in the control can change the associated combo
if (_getMenuItemValue(id_MENU_SPECIAL_SPACING) == spacing_MULTIPLE)
{
HWND h = GetDlgItem(m_hwndSpacing, AP_RID_DIALOG_PARA_COMBO_LEAD);
SendMessageW(h, CB_SETCURSEL, (WPARAM) _getMenuItemValue(id_MENU_SPECIAL_SPACING), 0);
}
}
if (bAll || (changed == id_MENU_SPECIAL_SPACING))
{
switch(_getMenuItemValue(id_MENU_SPECIAL_SPACING))
{
case spacing_SINGLE:
case spacing_ONEANDHALF:
case spacing_DOUBLE:
// clear the spin control
SetDlgItemText(m_hwndSpacing, AP_RID_DIALOG_PARA_EDIT_AT, NULL);
break;
default:
// set the spin control
SetDlgItemText(m_hwndSpacing, AP_RID_DIALOG_PARA_EDIT_AT, _getSpinItemValue(id_SPIN_SPECIAL_SPACING));
break;
}
}
// 3. move results of _doSpin() back to screen
if (!bAll)
{
// spin controls only sync when spun
switch (changed)
{
_syncSPIN(m_hwndSpacing, PARA_EDIT_LEFT, id_SPIN_LEFT_INDENT)
_syncSPIN(m_hwndSpacing, PARA_EDIT_RIGHT, id_SPIN_RIGHT_INDENT)
_syncSPIN(m_hwndSpacing, PARA_EDIT_BY, id_SPIN_SPECIAL_INDENT)
_syncSPIN(m_hwndSpacing, PARA_EDIT_BEFORE, id_SPIN_BEFORE_SPACING)
_syncSPIN(m_hwndSpacing, PARA_EDIT_AFTER, id_SPIN_AFTER_SPACING)
_syncSPIN(m_hwndSpacing, PARA_EDIT_AT, id_SPIN_SPECIAL_SPACING)
default:
break;
}
}
}
BOOL AP_Win32Dialog_Paragraph::_onInitTab(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
const XAP_StringSet * pSS = m_pApp->getStringSet();
UT_Win32LocaleString str;
// position ourselves w.r.t. containing tab
RECT r;
GetClientRect(m_hwndTab, &r);
TabCtrl_AdjustRect(m_hwndTab, FALSE, &r);
SetWindowPos(hWnd, HWND_TOP, r.left, r.top, 0, 0, SWP_NOSIZE);
// remember which window is which tab
TabParam * pTP = (TabParam *) lParam;
switch (pTP->which)
{
case AP_RID_DIALOG_PARA_TAB1: // first tab
{
m_hwndSpacing = hWnd;
// Hide Bidi Check Box unless required
{
HWND hwndBidi = GetDlgItem(hWnd, AP_RID_DIALOG_PARA_CHECK_BIDI);
ShowWindow(hwndBidi,SW_HIDE);
ShowWindow(hwndBidi,SW_SHOW);
}
// localize controls
_DS(PARA_TEXT_ALIGN, DLG_Para_LabelAlignment);
_DS(PARA_TEXT_INDENT, DLG_Para_LabelIndentation);
_DS(PARA_TEXT_LEFT, DLG_Para_LabelLeft);
_DS(PARA_TEXT_RIGHT, DLG_Para_LabelRight);
_DS(PARA_TEXT_HANG, DLG_Para_LabelSpecial);
_DS(PARA_TEXT_BY, DLG_Para_LabelBy);
_DS(PARA_TEXT_SPACING, DLG_Para_LabelSpacing);
_DS(PARA_TEXT_BEFORE, DLG_Para_LabelBefore);
_DS(PARA_TEXT_AFTER, DLG_Para_LabelAfter);
_DS(PARA_TEXT_LEAD, DLG_Para_LabelLineSpacing);
_DS(PARA_TEXT_AT, DLG_Para_LabelAt);
_DS(PARA_CHECK_BIDI, DLG_Para_DomDirection);
// populate fixed choices
{
HWND hwndAlign = GetDlgItem(hWnd, AP_RID_DIALOG_PARA_COMBO_ALIGN);
// insert the empty value (for multi-para selections with different state)
SendMessageW(hwndAlign, CB_ADDSTRING, 0, (LPARAM) L"");
_CAS(hwndAlign, DLG_Para_AlignLeft);
_CAS(hwndAlign, DLG_Para_AlignCentered);
_CAS(hwndAlign, DLG_Para_AlignRight);
_CAS(hwndAlign, DLG_Para_AlignJustified);
SendMessageW(hwndAlign, CB_SETCURSEL, (WPARAM) _getMenuItemValue(id_MENU_ALIGNMENT), 0);
HWND hwndHang = GetDlgItem(hWnd, AP_RID_DIALOG_PARA_COMBO_HANG);
SendMessageW(hwndHang, CB_ADDSTRING, 0, (LPARAM) L"");
_CAS(hwndHang, DLG_Para_SpecialNone);
_CAS(hwndHang, DLG_Para_SpecialFirstLine);
_CAS(hwndHang, DLG_Para_SpecialHanging);
SendMessageW(hwndHang, CB_SETCURSEL, (WPARAM) _getMenuItemValue(id_MENU_SPECIAL_INDENT), 0);
HWND hwndLead = GetDlgItem(hWnd, AP_RID_DIALOG_PARA_COMBO_LEAD);
SendMessageW(hwndLead, CB_ADDSTRING, 0, (LPARAM) L"");
_CAS(hwndLead, DLG_Para_SpacingSingle);
_CAS(hwndLead, DLG_Para_SpacingHalf);
_CAS(hwndLead, DLG_Para_SpacingDouble);
_CAS(hwndLead, DLG_Para_SpacingAtLeast);
_CAS(hwndLead, DLG_Para_SpacingExactly);
_CAS(hwndLead, DLG_Para_SpacingMultiple);
SendMessageW(hwndLead, CB_SETCURSEL, (WPARAM) _getMenuItemValue(id_MENU_SPECIAL_SPACING), 0);
}
// set initial state
_SST(PARA_EDIT_LEFT, id_SPIN_LEFT_INDENT);
_SST(PARA_EDIT_RIGHT, id_SPIN_RIGHT_INDENT);
_SST(PARA_EDIT_BY, id_SPIN_SPECIAL_INDENT);
_SST(PARA_EDIT_BEFORE, id_SPIN_BEFORE_SPACING);
_SST(PARA_EDIT_AFTER, id_SPIN_AFTER_SPACING);
_SST(PARA_EDIT_AT, id_SPIN_SPECIAL_SPACING);
_CDB(PARA_CHECK_BIDI, id_CHECK_DOMDIRECTION);
}
break;
case AP_RID_DIALOG_PARA_TAB2: // second tab
{
m_hwndBreaks = hWnd;
// localize controls
_DS(PARA_TEXT_PAGE, DLG_Para_LabelPagination);
_DS(PARA_CHECK_WIDOW, DLG_Para_PushWidowOrphanControl);
_DS(PARA_CHECK_NEXT, DLG_Para_PushKeepWithNext);
_DS(PARA_CHECK_TOGETHER, DLG_Para_PushKeepLinesTogether);
_DS(PARA_CHECK_BREAK, DLG_Para_PushPageBreakBefore);
_DS(PARA_CHECK_SUPPRESS, DLG_Para_PushSuppressLineNumbers);
_DS(PARA_CHECK_NOHYPHEN, DLG_Para_PushNoHyphenate);
// set initial state
_CDB(PARA_CHECK_WIDOW, id_CHECK_WIDOW_ORPHAN);
_CDB(PARA_CHECK_NEXT, id_CHECK_KEEP_NEXT);
_CDB(PARA_CHECK_TOGETHER, id_CHECK_KEEP_LINES);
_CDB(PARA_CHECK_BREAK, id_CHECK_PAGE_BREAK);
_CDB(PARA_CHECK_SUPPRESS, id_CHECK_SUPPRESS);
_CDB(PARA_CHECK_NOHYPHEN, id_CHECK_NO_HYPHENATE);
}
break;
default:
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
break;
}
// the following are common to each tab
_DS(PARA_TEXT_PREVIEW, DLG_Para_LabelPreview);
if (!m_pPreviewWidget)
{
// for XP purposes, life is simplest if we only have one preview
// widget which "floats" above both tabs. to get the window
// parentage right, we use the dimensions and location of the
// owner-draw control on the tab to position *another* dummy
// window which is parented by the main dialog instead.
HWND hwndChild = GetDlgItem(hWnd, AP_RID_DIALOG_PARA_PREVIEW);
HWND hwndFloater = GetDlgItem(m_hwndDlg, AP_RID_DIALOG_PARA_PREVIEW);
RECT r2;
GetWindowRect(hwndChild, &r2);
POINT pt;
pt.x = r2.left;
pt.y = r2.top;
ScreenToClient(m_hwndDlg, &pt);
SetWindowPos(hwndFloater, HWND_TOP, pt.x, pt.y,
r2.right - r2.left, r2.bottom - r2.top, SWP_NOREDRAW);
// use this floater window as a parent to the widget that we create
// here and thus have complete control of.
m_pPreviewWidget = new XAP_Win32PreviewWidget(static_cast<XAP_Win32App *>(m_pApp),
hwndFloater,
0);
// instantiate the XP preview object using the win32 preview widget (window)
// we just created. we seem to have a mish-mash of terms here, sorry.
UT_uint32 w,h;
m_pPreviewWidget->getWindowSize(&w,&h);
_createPreviewFromGC(m_pPreviewWidget->getGraphics(),w,h);
m_pPreviewWidget->setPreview(m_paragraphPreview); // we need this to call draw() on WM_PAINTs
// _updatePreview();
}
return 1; // 1 == we did not call SetFocus()
}
