bool s_RTF_ListenerGetProps::populate(PL_StruxFmtHandle /*sfh*/,
const PX_ChangeRecord * pcr)
{
switch (pcr->getType())
{
case PX_ChangeRecord::PXT_InsertSpan:
{
const PX_ChangeRecord_Span * pcrs = static_cast<const PX_ChangeRecord_Span *> (pcr);
PT_AttrPropIndex api = pcr->getIndexAP();
_openSpan(api);
PT_BufIndex bi = pcrs->getBufIndex();
_outputData(m_pDocument->getPointer(bi),pcrs->getLength());
return true;
}
case PX_ChangeRecord::PXT_InsertObject:
{
#if 0
const PX_ChangeRecord_Object * pcro = static_cast<const PX_ChangeRecord_Object *> (pcr);
PT_AttrPropIndex api = pcr->getIndexAP();
switch (pcro->getObjectType())
{
case PTO_Image:
_closeSpan();
_openTag("image",api);
return true;
case PTO_Field:
_closeSpan();
_openTag("field",api);
return true;
default:
UT_ASSERT_NOT_REACHED();
return false;
}
#endif
}
case PX_ChangeRecord::PXT_InsertFmtMark:
return true;
default:
UT_ASSERT_NOT_REACHED();
return false;
}
}
bool WordPerfect_Listener::populateStrux(pf_Frag_Strux* /*sdh*/,
const PX_ChangeRecord * pcr,
fl_ContainerLayout* * psfh)
{
const PX_ChangeRecord_Strux * pcrx = static_cast<const PX_ChangeRecord_Strux *>(pcr);
*psfh = 0; // we don't need it.
switch (pcrx->getStruxType())
{
case PTX_Section:
{
UT_DEBUGMSG(("WordPerfect Listener::_populateStrux PTX_Section\n"));
return true;
}
case PTX_SectionHdrFtr:
{
UT_DEBUGMSG(("WordPerfect Listener::_populateStrux PTX_SectionHdrFtr\n"));
return true;
}
case PTX_Block:
{
UT_DEBUGMSG(("WordPerfect Listener::_populateStrux PTX_Block\n"));
_closeBlock();
_openBlock(pcr->getIndexAP());
return true;
}
default:
UT_ASSERT_NOT_REACHED();
return false;
}
}
double UT_convertDimToInches (double f, UT_Dimension dim)
{
double result = 0.0;
switch(dim)
{
case DIM_IN:
result = f;
break;
case DIM_PI:
result = f / 6;
break;
case DIM_PT:
result = f / 72;
break;
case DIM_CM:
result = f / 2.54;
break;
case DIM_MM:
result = f / 25.4;
break;
case DIM_PX:
result = f / 72;
break;
default:
UT_DEBUGMSG(("Unknown dimension type: %d", dim));
UT_ASSERT_NOT_REACHED();
result = f;
}
return result;
}
/*!
Generate correct line break characters
Makes a line break correct for the encoding and platform.
*/
void Text_Listener::_genLineBreak(void)
{
char *pMB = static_cast<char *>(m_mbLineBreak);
const UT_UCSChar *pWC = 0;
int mbLen = 0;
// TODO Old Mac should use "\r". Mac OSX should Use U+2028 or U+2029.
#ifdef WIN32
static const UT_UCSChar wcLineBreak[3] = {'\r', '\n', 0};
#else
static const UT_UCSChar wcLineBreak[3] = {'\n', 0, 0};
#endif
for (pWC = wcLineBreak; *pWC; ++pWC)
{
if (_wctomb(pMB,mbLen,*pWC))
pMB += mbLen;
else
UT_ASSERT_NOT_REACHED();
}
m_iLineBreakLen = pMB - m_mbLineBreak;
UT_ASSERT_HARMLESS(m_iLineBreakLen && m_iLineBreakLen < 20);
}
void XAP_UnixDialog_Encoding::event_Ok(void)
{
GtkTreeSelection * selection;
GtkTreeIter iter;
GtkTreeModel * model;
gint row = 0;
selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_listEncodings) );
// if there is no selection, or the selection's data (GtkListItem widget)
// is empty, return cancel. GTK can make this happen.
if ( !selection ||
!gtk_tree_selection_get_selected (selection, &model, &iter)
)
{
_setAnswer (XAP_Dialog_Encoding::a_CANCEL);
return;
}
// get the ID of the selected Type
gtk_tree_model_get (model, &iter, 1, &row, -1);
if (row >= 0) {
_setSelectionIndex(static_cast<UT_uint32>(row));
_setEncoding (_getAllEncodings()[row]);
_setAnswer (XAP_Dialog_Encoding::a_OK);
} else {
UT_ASSERT_NOT_REACHED();
_setAnswer (XAP_Dialog_Encoding::a_CANCEL);
}
}
bool GR_VectorImage::render(GR_Graphics* pGR, UT_sint32 xDest, UT_sint32 yDest)
{
UT_UNUSED(pGR);
UT_UNUSED(xDest);
UT_UNUSED(yDest);
UT_ASSERT_NOT_REACHED();
return false;
}
bool IE_Imp::pasteFromBuffer(PD_DocumentRange * /*pDocRange*/,
const unsigned char * /*pData*/,
UT_uint32 /*lenData*/,
const char * /*szEncoding*/)
{
UT_ASSERT_NOT_REACHED();
return false;
}
bool WordPerfect_Listener::insertStrux(fl_ContainerLayout* /*sfh*/,
const PX_ChangeRecord * /*pcr*/,
pf_Frag_Strux* /*sdh*/,
PL_ListenerId /* lid */,
void (* /*pfnBindHandles*/)(pf_Frag_Strux* /* sdhNew */,
PL_ListenerId /* lid */,
fl_ContainerLayout* /* sfhNew */))
{
UT_ASSERT_NOT_REACHED(); // this function is not used.
return false;
}
bool s_RTF_ListenerGetProps::insertStrux(PL_StruxFmtHandle /*sfh*/,
const PX_ChangeRecord * /*pcr*/,
PL_StruxDocHandle /*sdh*/,
PL_ListenerId /* lid */,
void (* /*pfnBindHandles*/)(PL_StruxDocHandle /* sdhNew */,
PL_ListenerId /* lid */,
PL_StruxFmtHandle /* sfhNew */))
{
UT_ASSERT_NOT_REACHED(); // this function is not used.
return false;
}
bool ODe_AbiDocListener::insertStrux(PL_StruxFmtHandle /*sfh*/,
const PX_ChangeRecord * /*pcr*/,
PL_StruxDocHandle /*sdh*/,
PL_ListenerId /*lid*/,
void (* /*pfnBindHandles*/)(PL_StruxDocHandle sdhNew,
PL_ListenerId lid,
PL_StruxFmtHandle sfhNew))
{
UT_ASSERT_NOT_REACHED();
return true;
}
bool GR_CairoPrintGraphics::queryProperties(GR_Graphics::Properties gp) const
{
switch (gp)
{
case DGP_SCREEN:
case DGP_OPAQUEOVERLAY:
return false;
case DGP_PAPER:
return true;
default:
UT_ASSERT_NOT_REACHED ();
return false;
}
}
UT_Dimension UT_determineDimension(const char * sz, UT_Dimension fallback)
{
char * p = NULL ;
{
UT_LocaleTransactor t(LC_NUMERIC, "C");
strtod(sz, &p);
}
// p should now point to the unit
if (p && *p)
{
// trim off leading spaces
while (*p && isspace(*p))
p++;
if (g_ascii_strcasecmp(p,"in") == 0 || g_ascii_strcasecmp(p, "inch") == 0)
return DIM_IN;
else if (g_ascii_strcasecmp(p,"cm") == 0)
return DIM_CM;
else if (g_ascii_strcasecmp(p,"mm") == 0)
return DIM_MM;
else if (g_ascii_strcasecmp(p,"pi") == 0)
return DIM_PI;
else if (g_ascii_strcasecmp(p,"pt") == 0)
return DIM_PT;
else if (g_ascii_strcasecmp(p,"px") == 0)
return DIM_PX;
else if (g_ascii_strcasecmp(p,"%") == 0)
return DIM_PERCENT;
else if (g_ascii_strcasecmp(p,"*") == 0)
return DIM_STAR;
UT_DEBUGMSG(("ut_units - unknown unit presented '%s' \n",p));
UT_ASSERT_NOT_REACHED();
}
return fallback;
}
UT_Error OXML_Element::addToPT(PD_Document * pDocument)
{
UT_Error ret = UT_OK;
if (pDocument == NULL)
return UT_ERROR;
// const gchar ** atts = getAttributesWithProps();
switch (m_tag) {
case PG_BREAK:
{
UT_UCSChar ucs = UCS_FF;
ret = pDocument->appendSpan(&ucs, 1) ? UT_OK : UT_ERROR;
UT_return_val_if_fail(ret == UT_OK, ret);
}
break;
case CL_BREAK:
{
UT_UCSChar ucs = UCS_VTAB;
ret = pDocument->appendSpan(&ucs, 1) ? UT_OK : UT_ERROR;
UT_return_val_if_fail(ret == UT_OK, ret);
}
break;
case LN_BREAK:
{
UT_UCSChar ucs = UCS_LF;
ret = pDocument->appendSpan(&ucs, 1) ? UT_OK : UT_ERROR;
UT_return_val_if_fail(ret == UT_OK, ret);
}
break;
case P_TAG: //fall through to default
case R_TAG: //fall through to default
case T_TAG: //fall through to default
default:
UT_ASSERT_NOT_REACHED(); //We really shouldn't get here.
break;
}
ret = addChildrenToPT(pDocument);
return ret;
}
double UT_convertToPoints(const char* s)
{
if (!s || !*s)
return 0.;
double result = 0.;
double f = UT_convertDimensionless(s);
UT_Dimension dim = UT_determineDimension(s, (UT_Dimension)-1);
switch(dim)
{
case DIM_PT:
result = f;
break;
case DIM_PI:
result = f * 12;
break; // ie, 72 / 6
case DIM_IN:
result = f * 72;
break;
case DIM_CM:
result = f * 72 / 2.54;
break;
case DIM_MM:
result = f * 72 / 25.4;
break;
case DIM_PX:
result = f ;
break;
default:
UT_DEBUGMSG(("Unknown dimension type for: %s", s));
UT_ASSERT_NOT_REACHED();
if(f > 0.9)
{
result = f;
}
else
{
result = 12.; // default for a font-size
}
}
return result;
}
void XAP_UnixDialog_Language::event_setLang()
{
GtkTreeSelection * selection;
GtkTreeIter iter;
GtkTreeModel * model;
gint row = 0;
selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_pLanguageList) );
// if there is no selection, or the selection's data (GtkListItem widget)
// is empty, return cancel. GTK can make this happen.
if ( !selection ||
!gtk_tree_selection_get_selected (selection, &model, &iter)
)
{
m_answer = XAP_Dialog_Language::a_CANCEL;
return;
}
// get the ID of the selected Type
gtk_tree_model_get (model, &iter, 1, &row, -1);
if (row >= 0) {
if (!m_pLanguage || g_ascii_strcasecmp(m_pLanguage, m_ppLanguages[row]))
{
_setLanguage(m_ppLanguages[row]);
m_bChangedLanguage = true;
m_answer = XAP_Dialog_Language::a_OK;
bool b = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(m_cbDefaultLanguage));
setMakeDocumentDefault(b);
}
else {
m_answer = XAP_Dialog_Language::a_CANCEL;
}
} else {
UT_ASSERT_NOT_REACHED();
m_answer = XAP_Dialog_Language::a_CANCEL;
}
}
bool ODe_AbiDocListener::change(PL_StruxFmtHandle /*sfh*/, const PX_ChangeRecord * /*pcr*/)
{
UT_ASSERT_NOT_REACHED();
return true;
}
bool ODe_AbiDocListener::signal(UT_uint32 /*iSignal*/)
{
UT_ASSERT_NOT_REACHED();
return true;
}
GR_Font * GR_CairoPrintGraphics::getGUIFont(void)
{
UT_ASSERT_NOT_REACHED ();
return NULL;
}
bool s_RTF_ListenerGetProps::change(PL_StruxFmtHandle /*sfh*/,
const PX_ChangeRecord * /*pcr*/)
{
UT_ASSERT_NOT_REACHED(); // this function is not used.
return false;
}
bool s_RTF_ListenerGetProps::signal(UT_uint32 /* iSignal */)
{
UT_ASSERT_NOT_REACHED();
return false;
}
bool WordPerfect_Listener::signal(UT_uint32 /* iSignal */)
{
UT_ASSERT_NOT_REACHED();
return false;
}
bool WordPerfect_Listener::change(fl_ContainerLayout* /*sfh*/,
const PX_ChangeRecord * /*pcr*/)
{
UT_ASSERT_NOT_REACHED(); // this function is not used.
return false;
}
void IE_Imp_XML::charData(const gchar *s, int len)
{
// TODO gchar is defined in the xml parser
// TODO as a 'char' not as a 'unsigned char'.
// TODO does this cause any problems ??
xxx_UT_DEBUGMSG(("In IE_Imp_XML::charDat, len = %d parsestate %d \n",len,m_parseState));
if(!s || !len)
return;
X_EatIfAlreadyError(); // xml parser keeps running until buffer consumed
switch (m_parseState)
{
case _PS_Block:
case _PS_IgnoredWordsItem:
case _PS_Meta:
case _PS_Revision:
{
UT_UCS4String buf(s,static_cast<size_t>(len),!m_bWhiteSignificant);
xxx_UT_DEBUGMSG(("In IE_Imp_XML::charData buf.size %d \n",buf.size()));
// flush out the buffer
if (buf.size() == 0)
return;
switch (m_parseState)
{
case _PS_Block:
if (!m_bWhiteSignificant && m_bStripLeading && (buf[0] == UCS_SPACE))
{
if (buf.size () > 1)
{
X_CheckError(appendSpan (buf.ucs4_str()+1, buf.size()-1));
m_iCharCount += buf.size () - 1;
}
}
else
{
X_CheckError(appendSpan (buf.ucs4_str(), buf.size()));
m_iCharCount += buf.size ();
}
m_bStripLeading = (buf[buf.size()-1] == UCS_SPACE);
return;
case _PS_IgnoredWordsItem:
return;
case _PS_Meta:
{
UT_UTF8String data(s,len);
getDoc()->setMetaDataProp(m_currentMetaDataName, data);
return;
}
case _PS_Revision:
// 0 is not a valid revision Id
if(m_currentRevisionId)
{
UT_DEBUGMSG(("Doing revision \n"));
X_CheckError(getDoc()->addRevision(m_currentRevisionId,
buf.ucs4_str(),
buf.size(),
m_currentRevisionTime,
m_currentRevisionVersion));
// we need to reset the revision Id in order
// to be able to handle the case when there is
// no character data present in our
// endofelement handler
m_currentRevisionId = 0;
}
return;
default:
UT_ASSERT_NOT_REACHED();
return;
}
}
case _PS_Field:
{
// discard contents of the field - force recalculation
// this gives us a higher chance of correcting fields
// with the wrong values
return;
}
case _PS_DataItem:
{
#ifdef ENABLE_RESOURCE_MANAGER
XAP_ResourceManager & RM = getDoc()->resourceManager ();
XAP_Resource * resource = RM.current ();
if (resource == 0) break;
if (!resource->bInternal) break;
XAP_InternalResource * ri = dynamic_cast<XAP_InternalResource *>(resource);
if (m_currentDataItemEncoded) // base64-encoded data
ri->buffer (s, len, true);
else // old file-format keeping MathML & SVG in CDATA section :-(
{
/* since SVG import was only ever a DEBUG option, and is currently disabled (why?),
* since MathML was never supported except in principle, and since this CDATA stuff
* (unencoded) is pretty unsafe anyway, I'm going to postpone import support
* indefinitely... - fjf Aug. 19th '02
*/
}
#else /* ENABLE_RESOURCE_MANAGER */
#define MyIsWhite(c) (((c)==' ') || ((c)=='\t') || ((c)=='\n') || ((c)=='\r'))
if (m_currentDataItemEncoded)
{
// DataItem data consists of Base64 encoded data with
// white space added for readability. strip out any
// white space and put the rest in the ByteBuf.
UT_return_if_fail ((sizeof(gchar) == sizeof(UT_Byte)));
UT_uint32 actualLen = m_currentDataItem.getLength();
m_currentDataItem.ins(actualLen, len); // allocate all the possibly needed memory at once
const UT_Byte * ss = reinterpret_cast<const UT_Byte *>(s);
const UT_Byte * ssEnd = ss + len;
while (ss < ssEnd)
{
while ((ss < ssEnd) && MyIsWhite(*ss))
ss++;
UT_uint32 k=0;
while ((ss+k < ssEnd) && ( ! MyIsWhite(ss[k])))
k++;
if (k > 0)
{
m_currentDataItem.overwrite(actualLen, ss, k);
actualLen += k;
}
ss += k;
}
m_currentDataItem.truncate(actualLen); // chop off the mem we don't need after all
return;
}
else
m_currentDataItem.append(reinterpret_cast<const UT_Byte*>(s), len);
#undef MyIsWhite
#endif /* ENABLE_RESOURCE_MANAGER */
}
default:
UT_DEBUGMSG(("ie_imp_XML::charData Default just return \n"));
return;
}
}
bool GR_Image::render(GR_Graphics * /*pGR*/, UT_sint32 /*iDisplayWidth*/,
UT_sint32 /*iDisplayHeight*/)
{
UT_ASSERT_NOT_REACHED ();
return false;
}
bool s_RTF_ListenerGetProps::populateStrux(PL_StruxDocHandle /*sdh*/,
const PX_ChangeRecord * pcr,
PL_StruxFmtHandle * psfh)
{
UT_return_val_if_fail(pcr->getType() == PX_ChangeRecord::PXT_InsertStrux, false);
const PX_ChangeRecord_Strux * pcrx = static_cast<const PX_ChangeRecord_Strux *> (pcr);
*psfh = 0; // we don't need it.
switch (pcrx->getStruxType())
{
case PTX_Section:
{
_closeSpan();
_closeBlock();
_closeSection();
m_bInSection = true;
m_apiThisSection = pcr->getIndexAP();
return true;
}
case PTX_SectionHdrFtr:
{
_closeSpan();
_closeBlock();
_closeSection();
m_bInSection = true;
m_apiThisSection = pcr->getIndexAP();
return true;
}
case PTX_SectionTable:
{
_closeSpan();
_searchTableAPI(pcr->getIndexAP());
return true;
}
case PTX_SectionFootnote:
{
_closeSpan();
m_apiSavedBlock = m_apiThisBlock;
return true;
}
case PTX_EndFootnote:
{
_closeSpan();
_closeBlock();
m_apiThisBlock = m_apiSavedBlock;
return true;
}
case PTX_SectionAnnotation:
{
_closeSpan();
m_apiSavedBlock = m_apiThisBlock;
return true;
}
case PTX_EndAnnotation:
{
_closeSpan();
_closeBlock();
m_apiThisBlock = m_apiSavedBlock;
return true;
}
case PTX_SectionEndnote:
{
_closeSpan();
m_apiSavedBlock = m_apiThisBlock;
return true;
}
case PTX_SectionTOC:
{
_closeSpan();
return true;
}
case PTX_EndTOC:
{
_closeSpan();
return true;
}
case PTX_SectionFrame:
{
_closeSpan();
return true;
}
case PTX_EndFrame:
{
_closeSpan();
return true;
}
case PTX_EndEndnote:
{
_closeSpan();
_closeBlock();
m_apiThisBlock = m_apiSavedBlock;
return true;
}
case PTX_SectionCell:
{
_closeSpan();
_searchCellAPI(pcr->getIndexAP());
return true;
}
case PTX_EndTable:
{
_closeSpan();
return true;
}
case PTX_EndCell:
{
_closeSpan();
return true;
}
case PTX_Block:
{
_closeSpan();
_closeBlock();
m_bInBlock = true;
m_bHasBlock = true;
m_apiThisBlock = pcr->getIndexAP();
// Find colours of the Paragraph borders and shading
const PP_AttrProp * pBlockAP = NULL;
m_pDocument->getAttrProp(m_apiThisBlock,&pBlockAP);
const gchar * szColor = PP_evalProperty("bot-color",pBlockAP,NULL,NULL,m_pDocument,true);
UT_sint32 ndxColor = 0;
if (szColor)
{
ndxColor = m_pie->_findColor(static_cast<const char*>(szColor));
if (ndxColor == -1)
m_pie->_addColor(static_cast<const char*>(szColor));
}
szColor = PP_evalProperty("left-color",pBlockAP,NULL,NULL,m_pDocument,true);
if (szColor)
{
ndxColor = m_pie->_findColor(static_cast<const char*>(szColor));
if (ndxColor == -1)
m_pie->_addColor(static_cast<const char*>(szColor));
}
szColor = PP_evalProperty("right-color",pBlockAP,NULL,NULL,m_pDocument,true);
if (szColor)
{
ndxColor = m_pie->_findColor(static_cast<const char*>(szColor));
if (ndxColor == -1)
m_pie->_addColor(static_cast<const char*>(szColor));
}
szColor = PP_evalProperty("top-color",pBlockAP,NULL,NULL,m_pDocument,true);
if (szColor)
{
ndxColor = m_pie->_findColor(static_cast<const char*>(szColor));
if (ndxColor == -1)
m_pie->_addColor(static_cast<const char*>(szColor));
}
szColor = PP_evalProperty("shading-foreground-color",pBlockAP,NULL,NULL,m_pDocument,true);
if (szColor)
{
ndxColor = m_pie->_findColor(static_cast<const char*>(szColor));
if (ndxColor == -1)
m_pie->_addColor(static_cast<const char*>(szColor));
}
szColor = PP_evalProperty("shading-background-color",pBlockAP,NULL,NULL,m_pDocument,true);
if (szColor)
{
ndxColor = m_pie->_findColor(static_cast<const char*>(szColor));
if (ndxColor == -1)
m_pie->_addColor(static_cast<const char*>(szColor));
}
return true;
}
default:
UT_ASSERT_NOT_REACHED();
return false;
}
}
/*!
Check buffer for UTF-8 encoded characters
\param szBuf Buffer to check
\param iNumbytes Size of buffer
*/
bool IE_Imp_Text_Sniffer::_recognizeUTF8(const char * szBuf,
UT_uint32 iNumbytes)
{
bool bSuccess = false;
const unsigned char *p = reinterpret_cast<const unsigned char *>(szBuf);
while (p < reinterpret_cast<const unsigned char *>(szBuf + iNumbytes))
{
UT_sint32 iLen;
if (*p == 0) return false; // ??
if ((*p & 0x80) == 0) // ASCII
{
++p;
continue;
}
if ((*p & 0xc0) == 0x80) // not UTF-8
{
return false;
}
if (*p == 0xfe || *p == 0xff)
{
// BOM shouldn't occur in UTF-8 - file may be UCS-2
return false;
}
if ((*p & 0xfe) == 0xfc) // lead byte in 6-byte sequence
iLen = 6;
else if ((*p & 0xfc) == 0xf8) // lead byte in 5-byte sequence
iLen = 5;
else if ((*p & 0xf8) == 0xf0) // lead byte in 4-byte sequence
iLen = 4;
else if ((*p & 0xf0) == 0xe0) // lead byte in 3-byte sequence
iLen = 3;
else if ((*p & 0xe0) == 0xc0) // lead byte in 2-byte sequence
iLen = 2;
else
{
// the above code covers all cases - if we reach here the logic is wrong
UT_ASSERT_NOT_REACHED();
return false;
}
while (--iLen)
{
++p;
if (p >= reinterpret_cast<const unsigned char *>(szBuf + iNumbytes))
{
//UT_DEBUGMSG((" out of data!\n"));
break;
}
if ((*p & 0xc0) != 0x80)
return false;
}
// all bytes in sequence were ok
bSuccess = true;
++p;
}
return bSuccess;
}
pf_Frag_Object::pf_Frag_Object(pt_PieceTable * pPT,
PTObjectType objectType,
PT_AttrPropIndex indexAP)
: pf_Frag(pPT, pf_Frag::PFT_Object, pf_FRAG_OBJECT_LENGTH)
{
m_pObjectSubclass = NULL;
m_objectType = objectType;
m_indexAP = indexAP;
const PP_AttrProp * pAP = NULL;
xxx_UT_DEBUGMSG(("Frag Object created indexAP %x \n",m_indexAP));
m_pPieceTable->getAttrProp(m_indexAP,&pAP);
UT_return_if_fail (pAP);
const gchar* pszType = NULL;
const gchar* pszName = NULL;
const gchar* pszParam = NULL;
pAP->getAttribute(static_cast<const gchar *>("type"), pszType);
pAP->getAttribute(static_cast<const gchar *>("name"), pszName);
pAP->getAttribute(static_cast<const gchar *>("param"), pszParam);
fd_Field::FieldType fieldType = fd_Field::FD_None;
if (objectType==PTO_Field)
{
if(pszType == NULL)
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
pszType = "test";
}
switch(*pszType)
{
case 'a':
if (0 == strcmp(pszType, "app_ver"))
{
fieldType = fd_Field::FD_App_Version;
}
else if (0 == strcmp(pszType, "app_id"))
{
fieldType = fd_Field::FD_App_ID;
}
else if (0 == strcmp(pszType, "app_options"))
{
fieldType = fd_Field::FD_App_Options;
}
else if (0 == strcmp(pszType, "app_target"))
{
fieldType = fd_Field::FD_App_Target;
}
else if (0 == strcmp(pszType, "app_compiledate"))
{
fieldType = fd_Field::FD_App_CompileDate;
}
else if (0 == strcmp(pszType, "app_compiletime"))
{
fieldType = fd_Field::FD_App_CompileTime;
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
break;
case 'c':
if (0 == strcmp(pszType, "char_count"))
{
fieldType = fd_Field::FD_Doc_CharCount;
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
break;
case 'd':
if (0 == strcmp(pszType, "date"))
{
fieldType = fd_Field::FD_Date;
}
else if (0 == strcmp(pszType, "date_mmddyy"))
{
fieldType = fd_Field::FD_Date_MMDDYY;
}
else if (0 == strcmp(pszType, "date_ddmmyy"))
{
fieldType = fd_Field::FD_Date_DDMMYY;
}
else if (0 == strcmp(pszType, "date_mdy"))
{
fieldType = fd_Field::FD_Date_MDY;
}
else if (0 == strcmp(pszType, "date_mthdy"))
{
fieldType = fd_Field::FD_Date_MthDY;
}
else if (0 == strcmp(pszType, "date_dfl"))
{
fieldType = fd_Field::FD_Date_DFL;
}
else if (0 == strcmp(pszType, "date_ntdfl"))
{
fieldType = fd_Field::FD_Date_NTDFL;
}
else if (0 == strcmp(pszType, "date_wkday"))
{
fieldType = fd_Field::FD_Date_Wkday;
}
else if (0 == strcmp(pszType, "date_doy"))
{
fieldType = fd_Field::FD_Date_DOY;
}
else if (0 == strcmp(pszType, "datetime_custom"))
{
fieldType = fd_Field::FD_DateTime_Custom;
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
break;
case 'e':
if (0 == strcmp(pszType, "endnote_ref"))
{
fieldType = fd_Field::FD_Endnote_Ref;
}
else if (0 == strcmp(pszType, "endnote_anchor"))
{
fieldType = fd_Field::FD_Endnote_Anchor;
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
break;
case 'f':
if (0 == strcmp(pszType, "file_name"))
{
fieldType = fd_Field::FD_FileName;
}
else if (0 == strcmp(pszType, "footnote_ref"))
{
fieldType = fd_Field::FD_Footnote_Ref;
}
else if (0 == strcmp(pszType, "footnote_anchor"))
{
fieldType = fd_Field::FD_Footnote_Anchor;
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
break;
case 'l':
if (0 == strcmp(pszType, "list_label"))
{
fieldType = fd_Field::FD_ListLabel;
}
else if (0 == strcmp(pszType, "line_count"))
{
fieldType = fd_Field::FD_Doc_LineCount;
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
break;
case 'm':
if (0 == strcmp(pszType, "mail_merge"))
{
fieldType = fd_Field::FD_MailMerge;
}
else if(0 == strcmp(pszType, "meta_title"))
{
fieldType = fd_Field::FD_Meta_Title;
}
else if(0 == strcmp(pszType, "meta_creator"))
{
fieldType = fd_Field::FD_Meta_Creator;
}
else if(0 == strcmp(pszType, "meta_subject"))
{
fieldType = fd_Field::FD_Meta_Subject;
}
else if(0 == strcmp(pszType, "meta_publisher"))
{
fieldType = fd_Field::FD_Meta_Publisher;
}
else if(0 == strcmp(pszType, "meta_date"))
{
fieldType = fd_Field::FD_Meta_Date;
}
else if(0 == strcmp(pszType, "meta_type"))
{
fieldType = fd_Field::FD_Meta_Type;
}
else if(0 == strcmp(pszType, "meta_language"))
{
fieldType = fd_Field::FD_Meta_Language;
}
else if(0 == strcmp(pszType, "meta_rights"))
{
fieldType = fd_Field::FD_Meta_Rights;
}
else if(0 == strcmp(pszType, "meta_keywords"))
{
fieldType = fd_Field::FD_Meta_Keywords;
}
else if(0 == strcmp(pszType, "meta_contributor"))
{
fieldType = fd_Field::FD_Meta_Contributor;
}
else if(0 == strcmp(pszType, "meta_coverage"))
{
fieldType = fd_Field::FD_Meta_Coverage;
}
else if(0 == strcmp(pszType, "meta_description"))
{
fieldType = fd_Field::FD_Meta_Description;
}
else if (0 == strcmp(pszType, "martin_test"))
{
fieldType = fd_Field::FD_MartinTest;
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
break;
case 'n':
if (0 == strcmp(pszType, "nbsp_count"))
{
fieldType = fd_Field::FD_Doc_NbspCount;
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
break;
case 'p':
if (0 == strcmp(pszType, "page_number"))
{
fieldType = fd_Field::FD_PageNumber;
}
else if (0 == strcmp(pszType, "page_count"))
{
fieldType = fd_Field::FD_PageCount;
}
else if (0 == strcmp(pszType, "para_count"))
{
fieldType = fd_Field::FD_Doc_ParaCount;
}
else if (0 == strcmp(pszType, "page_ref"))
{
fieldType = fd_Field::FD_PageReference;
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
break;
case 's':
if(0 == strcmp(pszType, "sum_rows"))
{
fieldType = fd_Field::FD_Table_sum_rows;
}
if(0 == strcmp(pszType, "sum_cols"))
{
fieldType = fd_Field::FD_Table_sum_cols;
}
break;
case 't':
if (0 == strcmp(pszType, "test"))
{
fieldType = fd_Field::FD_Test;
}
else if (0 == strcmp(pszType, "time"))
{
fieldType = fd_Field::FD_Time;
}
else if (0 == strcmp(pszType, "time_miltime"))
{
fieldType = fd_Field::FD_Time_MilTime;
}
else if (0 == strcmp(pszType, "time_ampm"))
{
fieldType = fd_Field::FD_Time_AMPM;
}
else if (0 == strcmp(pszType, "time_zone"))
{
fieldType = fd_Field::FD_Time_Zone;
}
else if (0 == strcmp(pszType, "time_epoch"))
{
fieldType = fd_Field::FD_Time_Epoch;
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
break;
case 'w':
if (0 == strcmp(pszType, "word_count"))
{
fieldType = fd_Field::FD_Doc_WordCount;
}
else
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
break;
#if 0
// When adding new fields under any of these characters, please move
// the label up where it belongs
case 'b':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'o':
case 'q':
case 'r':
case 's':
case 'u':
case 'v':
case 'x':
case 'y':
case 'z':
#endif
default:
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
//Better than segfaulting I figure
fieldType = fd_Field::FD_None;
}
m_pField = new fd_Field(*this, pPT,fieldType, pszParam);
}
else if (objectType==PTO_Bookmark)
{
po_Bookmark::BookmarkType BT;
if(!pszType) {
// see bug 6489...
UT_ASSERT_NOT_REACHED();
BT = po_Bookmark::POBOOKMARK_END;
} else if(0 == strcmp(pszType, "end"))
BT = po_Bookmark::POBOOKMARK_END;
else
BT = po_Bookmark::POBOOKMARK_START;
UT_return_if_fail (pszName && *pszName);
m_pObjectSubclass = static_cast<void *>(new po_Bookmark(*this,pPT,BT, pszName));
}
}
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;
}
}
