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