template <class Type> sINLINE Type sSign(Type a) {return (a==0) ? Type(0) : (a>0) ? Type(1) : Type(-1);}
Vec2(const Dim2 &dim) {
m_v[0] = Type(dim.get_width());
m_v[1] = Type(dim.get_height());
}
void
nsAttrValue::ToString(nsAString& aResult) const
{
switch(Type()) {
case eString:
{
nsStringBuffer* str = static_cast<nsStringBuffer*>(GetPtr());
if (str) {
str->ToString(str->StorageSize()/sizeof(PRUnichar) - 1, aResult);
}
else {
aResult.Truncate();
}
break;
}
case eAtom:
{
nsIAtom *atom = static_cast<nsIAtom*>(GetPtr());
atom->ToString(aResult);
break;
}
case eInteger:
{
nsAutoString intStr;
intStr.AppendInt(GetIntInternal());
aResult = intStr;
break;
}
case eColor:
{
nscolor v;
GetColorValue(v);
NS_RGBToHex(v, aResult);
break;
}
case eEnum:
{
PRInt16 val = GetEnumValue();
const EnumTable* table = sEnumTableArray->
ElementAt(GetIntInternal() & NS_ATTRVALUE_ENUMTABLEINDEX_MASK);
while (table->tag) {
if (table->value == val) {
aResult.AssignASCII(table->tag);
return;
}
table++;
}
NS_NOTREACHED("couldn't find value in EnumTable");
break;
}
case ePercent:
{
nsAutoString intStr;
intStr.AppendInt(GetIntInternal());
aResult = intStr + NS_LITERAL_STRING("%");
break;
}
case eCSSStyleRule:
{
aResult.Truncate();
MiscContainer *container = GetMiscContainer();
nsCSSDeclaration* decl = container->mCSSStyleRule->GetDeclaration();
if (decl) {
decl->ToString(aResult);
}
break;
}
case eAtomArray:
{
MiscContainer* cont = GetMiscContainer();
PRInt32 count = cont->mAtomArray->Count();
if (count) {
cont->mAtomArray->ObjectAt(0)->ToString(aResult);
nsAutoString tmp;
PRInt32 i;
for (i = 1; i < count; ++i) {
cont->mAtomArray->ObjectAt(i)->ToString(tmp);
aResult.Append(NS_LITERAL_STRING(" ") + tmp);
}
}
else {
aResult.Truncate();
}
break;
}
#ifdef MOZ_SVG
case eSVGValue:
{
GetMiscContainer()->mSVGValue->GetValueString(aResult);
}
#endif
}
}
HDINLINE operator Type() const
{
return Type();
}
Type Cursor::getCursorType() {
auto type = clang_getCursorType(cursor_);
return Type(std::move(type));
}
bool IsPrefix(AST* expr)
{
assert(isUnaryOp(Type(expr)));
return (expr->second != NULL);
}
mcSparse,
mcDense,
mcNumericDense,
mcNumericSparse,
mc2DNumericDense,
mc2DNumericSparse
} EMatrixClass;
template <class Type> class CDenseMatrix;
template <class Type> class CSparseMatrix;
template <class Type> class PNL_API CMatrix : public CReferenceCounter
{
public:
virtual CMatrix<Type>* CreateEmptyMatrix( int dim, const int *range,
int Clamp, Type defaultVal = Type(0) )const = 0;
//method the same as operator = but virtual
virtual void SetDataFromOtherMatrix( const CMatrix<Type>* matInput ) = 0;
virtual CMatrix<Type>* Clone() const = 0;
virtual int GetNumberDims() const = 0;
virtual void GetRanges(int *numOfDimsOut, const int **rangesOut) const = 0;
virtual EMatrixClass GetMatrixClass() const;
//methods for conversion from other type
//if requered type is the same as type of argument - return copy of object
virtual CDenseMatrix<Type>* ConvertToDense() const = 0;
virtual CSparseMatrix<Type>* ConvertToSparse() const = 0;
//auxillary methods to work with matrix
//methods for viewing/change data
virtual Type GetElementByIndexes(const int *multidimindexes) const = 0;
virtual void SetElementByIndexes(Type value, const int *multidimindexes) = 0;
//these functions set matrix element equal value (for
Type pweibull(Type x, Type shape, Type scale)
{
return CppAD::CondExpGe(x,Type(0),1-exp(-pow(x/scale,shape)),Type(0));
}
Type df(Type x, Type df1, Type df2, int give_log)
{
Type logres = lgamma((df1+df2)/2.) - lgamma(df1/2.) - lgamma(df2/2.) + df1/2.*log(Type(df1)/df2) + (df1/2.-1)*log(x) - (df1+df2)/2.*log(1+Type(df1)/df2*x);
if(!give_log) return exp(logres);
else return logres;
}
bool MgComposite::_isKindOf(int type) const
{
return type == Type() || MgBaseShape::_isKindOf(type);
}
ToolScript*
BrushTool::UseTool(ImageView *view, uint32 buttons, BPoint point, BPoint viewPoint)
{
B_UNUSED(buttons)
B_UNUSED(viewPoint)
// Wait for the last_updated_region to become empty
while (LastUpdatedRect().IsValid())
snooze(50000);
CoordinateReader* coordinate_reader = new CoordinateReader(view,
LINEAR_INTERPOLATION, false);
ToolScript* the_script = new ToolScript(Type(), fToolSettings,
((PaintApplication*)be_app)->Color(true));
selection = view->GetSelection();
BBitmap* buffer = view->ReturnImage()->ReturnActiveBitmap();
bits = (uint32*)buffer->Bits();
bpr = buffer->BytesPerRow()/4;
BRect bitmap_bounds = buffer->Bounds();
left_bound = (int32)bitmap_bounds.left;
right_bound = (int32)bitmap_bounds.right;
top_bound = (int32)bitmap_bounds.top;
bottom_bound = (int32)bitmap_bounds.bottom;
float brush_width_per_2 = floor(brush->Width()/2);
Veh_Distribution::Veh_Distribution (void)
{
Type (0);
Sub_Type (0);
Share (0.0);
}
void __cdecl callback_serverkey(int keyid, void* outbuf, void *userdata)
{
if (!userdata) return;
xrGameSpyServer* pServer = (xrGameSpyServer*) userdata;
if (!pServer) return;
CGameSpy_QR2* pQR2 = pServer->QR2();
if (!pQR2) return;
game_sv_mp* gmMP = smart_cast<game_sv_mp*>(pServer->game);
game_sv_Deathmatch* gmDM = smart_cast<game_sv_Deathmatch*>(pServer->game);
game_sv_TeamDeathmatch* gmTDM = smart_cast<game_sv_TeamDeathmatch*>(pServer->game);
game_sv_ArtefactHunt* gmAhunt = smart_cast<game_sv_ArtefactHunt*>(pServer->game);
string4096 game_version;
switch (keyid)
{
case HOSTNAME_KEY: pQR2->BufferAdd(outbuf, pServer->HostName.c_str()); break;
case MAPNAME_KEY: pQR2->BufferAdd(outbuf, pServer->MapName.c_str()); break;
case GAMEVER_KEY: pQR2->BufferAdd(outbuf, pQR2->GetGameVersion(game_version)); break;
case NUMPLAYERS_KEY: pQR2->BufferAdd_Int(outbuf, pServer->GetPlayersCount()); break;
case MAXPLAYERS_KEY: pQR2->BufferAdd_Int(outbuf, pServer->m_iMaxPlayers); break;
case GAMETYPE_KEY: ADD_KEY_VAL(pServer->game, pQR2, BufferAdd, outbuf, type_name()); break; // pQR2->BufferAdd(outbuf, pServer->game->type_name()); break;
case GAMEMODE_KEY: pQR2->BufferAdd(outbuf, "openplaying"); break;
case PASSWORD_KEY:
if ( 0 == *(pServer->Password) )
{
pQR2->BufferAdd_Int( outbuf, 0 );
}
else
{
pQR2->BufferAdd_Int( outbuf, 1 );
}
break;
case G_USER_PASSWORD_KEY:
if ( pServer->HasProtected() )
{
pQR2->BufferAdd_Int( outbuf, 1 );
}
else
{
pQR2->BufferAdd_Int( outbuf, 0 );
}
break;
case G_BATTLEYE_KEY:
#ifdef BATTLEYE
if ( g_pGameLevel && Level().battleye_system.server )
{
pQR2->BufferAdd_Int( outbuf, 1 );
}
else
{
pQR2->BufferAdd_Int( outbuf, 0 );
}
#endif // BATTLEYE
break;
case HOSTPORT_KEY: pQR2->BufferAdd_Int(outbuf, pServer->GetPort()); break;
case DEDICATED_KEY: pQR2->BufferAdd_Int(outbuf, pServer->IsDedicated()); break;
case GAMETYPE_NAME_KEY: ADD_KEY_VAL(pServer->game, pQR2, BufferAdd_Int, outbuf, Type()); break; //pQR2->BufferAdd_Int(outbuf, pServer->game->Type()); break;
case NUMTEAMS_KEY: ADD_KEY_VAL(gmMP, pQR2, BufferAdd_Int, outbuf, GetNumTeams()); break; //pQR2->BufferAdd_Int(outbuf, gmMP->GetNumTeams()); break;
case G_MAX_PING_KEY: pQR2->BufferAdd_Int(outbuf, g_sv_dwMaxClientPing); break;
//------- game ---------//
case G_MAP_ROTATION_KEY: ADD_KEY_VAL(gmDM, pQR2, BufferAdd_Int, outbuf, HasMapRotation()); break; //if (gmDM) pQR2->BufferAdd_Int(outbuf, gmDM->HasMapRotation()); else pQR2->BufferAdd(outbuf, ""); break;
case G_VOTING_ENABLED_KEY: ADD_KEY_VAL(gmDM, pQR2, BufferAdd_Int, outbuf, IsVotingEnabled()); break; //if (gmDM) pQR2->BufferAdd_Int(outbuf, gmDM->IsVotingEnabled()); else pQR2->BufferAdd(outbuf, ""); break;
case G_SPECTATOR_MODES_KEY: ADD_KEY_VAL(gmDM, pQR2, BufferAdd_Int, outbuf, GetSpectatorModes()); break; //if (gmDM) pQR2->BufferAdd_Int(outbuf, gmDM->GetSpectatorModes()); else pQR2->BufferAdd(outbuf, ""); break;
//------- deathmatch -------//
case G_FRAG_LIMIT_KEY: ADD_KEY_VAL(gmDM, pQR2, BufferAdd_Int, outbuf, GetFragLimit()); break; //if (gmDM)pQR2->BufferAdd_Int(outbuf, gmDM->GetFragLimit()); else pQR2->BufferAdd(outbuf, ""); break;
case G_TIME_LIMIT_KEY: ADD_KEY_VAL(gmDM, pQR2, BufferAdd_Int, outbuf, GetTimeLimit()); break; //if (gmDM)pQR2->BufferAdd_Int(outbuf, gmDM->GetTimeLimit()); else pQR2->BufferAdd(outbuf, ""); break;
case G_DAMAGE_BLOCK_TIME_KEY: ADD_KEY_VAL(gmDM, pQR2, BufferAdd_Int, outbuf, GetDMBLimit()); break; //if (gmDM)pQR2->BufferAdd_Int(outbuf, gmDM->GetDMBLimit()); else pQR2->BufferAdd(outbuf, ""); break;
case G_DAMAGE_BLOCK_INDICATOR_KEY: ADD_KEY_VAL(gmDM, pQR2, BufferAdd_Int, outbuf, IsDamageBlockIndEnabled()); break; //if (gmDM)pQR2->BufferAdd_Int(outbuf, gmDM->IsDamageBlockIndEnabled()); else pQR2->BufferAdd(outbuf, ""); break;
case G_ANOMALIES_ENABLED_KEY: ADD_KEY_VAL(gmDM, pQR2, BufferAdd_Int, outbuf, IsAnomaliesEnabled()); break; //if (gmDM)pQR2->BufferAdd_Int(outbuf, gmDM->IsAnomaliesEnabled()); else pQR2->BufferAdd(outbuf, ""); break;
case G_ANOMALIES_TIME_KEY: ADD_KEY_VAL(gmDM, pQR2, BufferAdd_Int, outbuf, GetAnomaliesTime()); break; //if (gmDM)pQR2->BufferAdd_Int(outbuf, gmDM->GetAnomaliesTime()); else pQR2->BufferAdd(outbuf, ""); break;
case G_WARM_UP_TIME_KEY: ADD_KEY_VAL(gmDM, pQR2, BufferAdd_Int, outbuf, GetWarmUpTime()); break; //if (gmDM)pQR2->BufferAdd_Int(outbuf, gmDM->GetWarmUpTime()); else pQR2->BufferAdd(outbuf, ""); break;
case G_FORCE_RESPAWN_KEY: ADD_KEY_VAL(gmDM, pQR2, BufferAdd_Int, outbuf, GetForceRespawn()); break; //if (gmDM)pQR2->BufferAdd_Int(outbuf, gmDM->GetForceRespawn()); else pQR2->BufferAdd(outbuf, ""); break;
//---- game_sv_teamdeathmatch ----
case G_AUTO_TEAM_BALANCE_KEY: ADD_KEY_VAL(gmTDM, pQR2, BufferAdd_Int, outbuf, Get_AutoTeamBalance()); break; //if (gmTDM)pQR2->BufferAdd_Int(outbuf, gmTDM->Get_AutoTeamBalance ()); break;
case G_AUTO_TEAM_SWAP_KEY: ADD_KEY_VAL(gmTDM, pQR2, BufferAdd_Int, outbuf, Get_AutoTeamSwap()); break; //if (gmTDM)pQR2->BufferAdd_Int(outbuf, gmTDM->Get_AutoTeamSwap ()); break;
case G_FRIENDLY_INDICATORS_KEY: ADD_KEY_VAL(gmTDM, pQR2, BufferAdd_Int, outbuf, Get_FriendlyIndicators()); break; //if (gmTDM)pQR2->BufferAdd_Int(outbuf, gmTDM->Get_FriendlyIndicators ()); break;
case G_FRIENDLY_NAMES_KEY: ADD_KEY_VAL(gmTDM, pQR2, BufferAdd_Int, outbuf, Get_FriendlyNames()); break; //if (gmTDM)pQR2->BufferAdd_Int(outbuf, gmTDM->Get_FriendlyNames ()); break;
case G_FRIENDLY_FIRE_KEY: ADD_KEY_VAL_INT(gmTDM, pQR2, BufferAdd_Int, outbuf, GetFriendlyFire()*100.0f); break; //if (gmTDM)pQR2->BufferAdd_Int(outbuf, int(gmTDM->GetFriendlyFire()*100.0f)); break;
//---- game_sv_artefacthunt ----
case G_ARTEFACTS_COUNT_KEY: ADD_KEY_VAL(gmAhunt, pQR2, BufferAdd_Int, outbuf, Get_ArtefactsCount()); break; //if (gmAhunt) pQR2->BufferAdd_Int(outbuf, gmAhunt->Get_ArtefactsCount ()); break;
case G_ARTEFACT_STAY_TIME_KEY: ADD_KEY_VAL(gmAhunt, pQR2, BufferAdd_Int, outbuf, Get_ArtefactsStayTime()); break; //if (gmAhunt) pQR2->BufferAdd_Int(outbuf, gmAhunt->Get_ArtefactsStayTime ()); break;
case G_ARTEFACT_RESPAWN_TIME_KEY: ADD_KEY_VAL(gmAhunt, pQR2, BufferAdd_Int, outbuf, Get_ArtefactsRespawnDelta()); break; //if (gmAhunt) pQR2->BufferAdd_Int(outbuf, gmAhunt->Get_ArtefactsRespawnDelta ()); break;
case G_REINFORCEMENT_KEY: ADD_KEY_VAL(gmAhunt, pQR2, BufferAdd_Int, outbuf, Get_ReinforcementTime()); break; //if (gmAhunt) pQR2->BufferAdd_Int(outbuf, gmAhunt->Get_ReinforcementTime ()); break;
case G_SHIELDED_BASES_KEY: ADD_KEY_VAL(gmAhunt, pQR2, BufferAdd_Int, outbuf, Get_ShieldedBases()); break; //if (gmAhunt) pQR2->BufferAdd_Int(outbuf, gmAhunt->Get_ShieldedBases ()); break;
case G_RETURN_PLAYERS_KEY: ADD_KEY_VAL(gmAhunt, pQR2, BufferAdd_Int, outbuf, Get_ReturnPlayers()); break; //if (gmAhunt) pQR2->BufferAdd_Int(outbuf, gmAhunt->Get_ReturnPlayers ()); break;
case G_BEARER_CANT_SPRINT_KEY: ADD_KEY_VAL(gmAhunt, pQR2, BufferAdd_Int, outbuf, Get_BearerCantSprint()); break; //if (gmAhunt) pQR2->BufferAdd_Int(outbuf, gmAhunt->Get_BearerCantSprint ()); break;
default:
{
// R_ASSERT2(0, "Unknown GameSpy Server key ");
pQR2->BufferAdd(outbuf, "");
}break;
}
//GSI_UNUSED(userdata);
};
DataPackage() : type(Type(-1)), sendMode(eNet_ReliableOrdered), repRules(Net_REPRULE_NONE) {}
/*--------------------------------------------------------------------------*/
PegPrompt::PegPrompt(SIGNED iLeft, SIGNED iTop, SIGNED iWidth,
const PEGCHAR *Text, WORD wId, WORD wStyle, PegFont *pFont) :
PegThing(wId, wStyle), PegTextThing(Text, wStyle & TT_COPY, PEG_PROMPT_FONT)
{
Type(TYPE_PROMPT);
if (pFont)
{
mpFont = pFont;
}
mReal.wLeft = iLeft;
mReal.wTop = iTop;
mReal.wRight = mReal.wLeft + iWidth;
mReal.wBottom = mReal.wTop + TextHeight(lsTEST, mpFont) + 2;
switch(wStyle & FF_MASK)
{
case FF_THICK:
mReal.wBottom += PEG_FRAME_WIDTH * 2;
break;
case FF_THIN:
mReal.wBottom += 2;
break;
#ifdef PEG_RUNTIME_COLOR_CHECK
case FF_RAISED:
case FF_RECESSED:
if (NumColors() >= 4)
{
mReal.wBottom += 4;
}
else
{
mReal.wBottom += 2;
}
break;
#else
#if (PEG_NUM_COLORS != 2)
case FF_RAISED:
case FF_RECESSED:
mReal.wBottom += 4;
break;
#endif
#endif
default:
break;
}
InitClient();
if (!(wStyle & AF_ENABLED))
{
RemoveStatus(PSF_SELECTABLE|PSF_ACCEPTS_FOCUS);
}
else
{
AddStatus(PSF_TAB_STOP);
SetSignals(SIGMASK(PSF_FOCUS_RECEIVED));
}
muColors[PCI_NTEXT] = PCLR_NORMAL_TEXT;
muColors[PCI_SELECTED] = PCLR_HIGH_TEXT_BACK;
muColors[PCI_STEXT] = PCLR_HIGH_TEXT;
muColors[PCI_NORMAL] = PCLR_CLIENT;
}
Type dsn(Type x, Type alpha, int give_log=0)
{
if(!give_log) return 2 * dnorm(x,Type(0),Type(1),0) * pnorm(alpha*x);
else return log(2.0) + log(dnorm(x,Type(0),Type(1),0)) + log(pnorm(alpha*x));
}
int Ardb::Sort(const DBID& db, const Slice& key, const StringArray& args,
ValueArray& values)
{
SortOptions options;
if (parse_sort_options(options, args) < 0)
{
DEBUG_LOG("Failed to parse sort options.");
return ERR_INVALID_ARGS;
}
int type = Type(db, key);
ValueArray sortvals;
switch (type)
{
case LIST_META:
{
LRange(db, key, 0, -1, sortvals);
break;
}
case SET_ELEMENT:
{
SMembers(db, key, sortvals);
break;
}
case ZSET_ELEMENT_SCORE:
{
QueryOptions tmp;
ZRange(db, key, 0, -1, sortvals, tmp);
if(NULL == options.by)
{
options.nosort = true;
}
break;
}
default:
{
return ERR_INVALID_TYPE;
}
}
if (sortvals.empty())
{
return 0;
}
if (options.with_limit)
{
if (options.limit_offset < 0)
{
options.limit_offset = 0;
}
if ((uint32) options.limit_offset > sortvals.size())
{
values.clear();
return 0;
}
if (options.limit_count < 0)
{
options.limit_count = sortvals.size();
}
}
std::vector<SortValue> sortvec;
if (!options.nosort)
{
if (NULL != options.by)
{
sortvec.reserve(sortvals.size());
}
for (uint32 i = 0; i < sortvals.size(); i++)
{
if (NULL != options.by)
{
sortvec.push_back(SortValue(&sortvals[i]));
if (GetValueByPattern(db, options.by, sortvals[i],
sortvec[i].cmp) < 0)
{
DEBUG_LOG("Failed to get value by pattern:%s", options.by);
sortvec[i].cmp.Clear();
continue;
}
}
if (options.with_alpha)
{
if (NULL != options.by)
{
value_convert_to_raw(sortvec[i].cmp);
}
else
{
value_convert_to_raw(sortvals[i]);
}
}
else
{
if (NULL != options.by)
{
value_convert_to_number(sortvec[i].cmp);
}
else
{
value_convert_to_number(sortvals[i]);
}
}
}
if (NULL != options.by)
{
if (!options.is_desc)
{
std::sort(sortvec.begin(), sortvec.end(),
less_value<SortValue>);
}
else
{
std::sort(sortvec.begin(), sortvec.end(),
greater_value<SortValue>);
}
}
else
{
if (!options.is_desc)
{
std::sort(sortvals.begin(), sortvals.end(),
less_value<ValueObject>);
}
else
{
std::sort(sortvals.begin(), sortvals.end(),
greater_value<ValueObject>);
}
}
}
if (!options.with_limit)
{
options.limit_offset = 0;
options.limit_count = sortvals.size();
}
uint32 count = 0;
for (uint32 i = options.limit_offset;
i < sortvals.size() && count < (uint32) options.limit_count;
i++, count++)
{
ValueObject* patternObj = NULL;
if (NULL != options.by)
{
patternObj = sortvec[i].value;
}
else
{
patternObj = &(sortvals[i]);
}
if (options.get_patterns.empty())
{
values.push_back(*patternObj);
}
else
{
for (uint32 j = 0; j < options.get_patterns.size(); j++)
{
ValueObject vo;
if (GetValueByPattern(db, options.get_patterns[j],
*patternObj, vo) < 0)
{
DEBUG_LOG("Failed to get value by pattern for:%s", options.get_patterns[j]);
vo.Clear();
}
values.push_back(vo);
}
}
}
if (options.store_dst != NULL && !values.empty())
{
BatchWriteGuard guard(GetEngine());
LClear(db, options.store_dst);
ValueArray::iterator it = values.begin();
uint64 score = 0;
while (it != values.end())
{
if (it->type != EMPTY)
{
ListKeyObject lk(options.store_dst, score, db);
SetValue(lk, *it);
score++;
}
it++;
}
ListMetaValue meta;
meta.min_score = 0;
meta.max_score = (score - 1);
meta.size = score;
SetListMetaValue(db, options.store_dst, meta);
}
return 0;
}
Type dt(Type x, Type df, int give_log)
{
Type logres = lgamma((df+1)/2) - Type(1)/2*log(df*M_PI) -lgamma(df/2) - (df+1)/2*log(1+x*x/df);
if(!give_log) return exp(logres);
else return logres;
}
bool IsPostfix(AST* expr)
{
assert(isUnaryOp(Type(expr)));
return (expr->first != NULL);
}
Type pexp(Type x, Type rate)
{
return CppAD::CondExpGe(x,Type(0),1-exp(-rate*x),Type(0));
}
inline void operator()(SOARef v, std::size_t i, int m = 0) const
{
v = Type(1+i+m);
}
Entity::Entity() : pos(), body(NULL){
name = "UNNAMED";
type=Type(OTHER);
//currAnm = animations[0];
}
void operator()(Type& object, const Type& operand)const
{
if(object == operand)
object = Type();
}
virtual String defineEditHtml(Named*, String const& _mid)
{
return L"<span class=\"keyword\">" + Type(Bool)->typeHtml(_mid) + "</span>";
}
/**
* Constructor from DCM matrix
*
* Instance is set from Dcm representing transformation from
* frame 2 to frame 1.
* This instance will hold the angles defining the 3-2-1 intrinsic
* Tait-Bryan rotation sequence from frame 1 to frame 2.
*
* @param dcm Direction cosine matrix
*/
Euler(const Dcm<Type> &dcm) : Vector<Type, 3>()
{
Type phi_val = Type(atan2(dcm(2, 1), dcm(2, 2)));
Type theta_val = Type(asin(-dcm(2, 0)));
Type psi_val = Type(atan2(dcm(1, 0), dcm(0, 0)));
Type pi = Type(M_PI);
if (Type(fabs(theta_val - pi / Type(2))) < Type(1.0e-3)) {
phi_val = Type(0.0);
psi_val = Type(atan2(dcm(1, 2), dcm(0, 2)));
} else if (Type(fabs(theta_val + pi / Type(2))) < Type(1.0e-3)) {
phi_val = Type(0.0);
psi_val = Type(atan2(-dcm(1, 2), -dcm(0, 2)));
}
phi() = phi_val;
theta() = theta_val;
psi() = psi_val;
}
BOOST_FORCEINLINE
Type operator ()() const
{
return Type();
}
HRESULT MAPIContact::Init()
{
HRESULT hr = S_OK;
Zimbra::Util::ScopedBuffer<SPropValue> pPropValMsgClass;
if (FAILED(hr = HrGetOneProp(m_pMessage, PR_MESSAGE_CLASS, pPropValMsgClass.getptr())))
throw MAPIContactException(hr, L"Init(): HrGetOneProp Failed.",
ERR_MAPI_CONTACT, __LINE__, __FILE__);
if ((pPropValMsgClass->ulPropTag == PR_MESSAGE_CLASS_W) && (_tcsicmp(
pPropValMsgClass->Value.LPSZ, L"ipm.distlist") == 0))
m_bPersonalDL = true;
// initialize the MAPINAMEID structure GetIDsFromNames requires
LPMAPINAMEID ppNames[N_NUM_NAMES] = { 0 };
for (int i = 0; i < N_NUM_NAMES; i++)
{
MAPIAllocateBuffer(sizeof (MAPINAMEID), (LPVOID *)&(ppNames[i]));
ppNames[i]->ulKind = MNID_ID;
ppNames[i]->lpguid = (LPGUID)(&PS_CONTACT_PROPERTIES);
ppNames[i]->Kind.lID = nameIds[i];
}
// get the real prop tag ID's
LPSPropTagArray pContactTags = NULL;
if (FAILED(hr = m_pMessage->GetIDsFromNames(N_NUM_NAMES, ppNames, MAPI_CREATE,
&pContactTags)))
throw MAPIContactException(hr, L"Init(): GetIDsFromNames Failed.",
ERR_MAPI_CONTACT, __LINE__, __FILE__);
// give the prop tag ID's a type
pr_mail1address = SetPropType(pContactTags->aulPropTag[N_MAIL1], PT_TSTRING);
pr_mail1entryid = SetPropType(pContactTags->aulPropTag[N_MAIL1EID], PT_BINARY);
pr_mail1type = SetPropType(pContactTags->aulPropTag[N_MAIL1TYPE], PT_TSTRING);
pr_mail1dispname = SetPropType(pContactTags->aulPropTag[N_MAIL1DISPNAME], PT_TSTRING);
pr_mail2address = SetPropType(pContactTags->aulPropTag[N_MAIL2], PT_TSTRING);
pr_mail2entryid = SetPropType(pContactTags->aulPropTag[N_MAIL2EID], PT_BINARY);
pr_mail2type = SetPropType(pContactTags->aulPropTag[N_MAIL2TYPE], PT_TSTRING);
pr_mail2dispname = SetPropType(pContactTags->aulPropTag[N_MAIL2DISPNAME], PT_TSTRING);
pr_mail3address = SetPropType(pContactTags->aulPropTag[N_MAIL3], PT_TSTRING);
pr_mail3entryid = SetPropType(pContactTags->aulPropTag[N_MAIL3EID], PT_BINARY);
pr_mail3type = SetPropType(pContactTags->aulPropTag[N_MAIL3TYPE], PT_TSTRING);
pr_mail3dispname = SetPropType(pContactTags->aulPropTag[N_MAIL3DISPNAME], PT_TSTRING);
pr_fileas = SetPropType(pContactTags->aulPropTag[N_FILEAS], PT_TSTRING);
pr_fileasID = SetPropType(pContactTags->aulPropTag[N_FILEAS_ID], PT_LONG);
pr_business_address_city = SetPropType(pContactTags->aulPropTag[N_BUS_CITY], PT_TSTRING);
pr_business_address_country = SetPropType(pContactTags->aulPropTag[N_BUS_COUNTRY],
PT_TSTRING);
pr_business_address_postal_code = SetPropType(pContactTags->aulPropTag[N_BUS_ZIP],
PT_TSTRING);
pr_business_address_state = SetPropType(pContactTags->aulPropTag[N_BUS_STATE], PT_TSTRING);
pr_business_address_street = SetPropType(pContactTags->aulPropTag[N_BUS_STREET],
PT_TSTRING);
pr_contact_user1_idx = SetPropType(pContactTags->aulPropTag[N_CONTACT_USER1_IDX],
PT_TSTRING);
pr_contact_user2_idx = SetPropType(pContactTags->aulPropTag[N_CONTACT_USER2_IDX],
PT_TSTRING);
pr_contact_user3_idx = SetPropType(pContactTags->aulPropTag[N_CONTACT_USER3_IDX],
PT_TSTRING);
pr_contact_user4_idx = SetPropType(pContactTags->aulPropTag[N_CONTACT_USER4_IDX],
PT_TSTRING);
pr_contact_oneoffmemebrs = SetPropType(
pContactTags->aulPropTag[N_CONTACT_ONEOFFMEMEBRS_IDX], PT_MV_BINARY);
pr_imaddress = SetPropType(pContactTags->aulPropTag[N_IMADDRESS], PT_TSTRING);
pr_anniversary = SetPropType(pContactTags->aulPropTag[N_ANNIVERSARY], PT_TSTRING);
// free the memory we allocated on the head
for (int i = 0; i < N_NUM_NAMES; i++)
MAPIFreeBuffer(ppNames[i]);
MAPIFreeBuffer(pContactTags);
// these are the contact properties we need to get
SizedSPropTagArray(C_NUM_PROPS, contactProps) = {
C_NUM_PROPS, {
PR_CALLBACK_TELEPHONE_NUMBER, PR_CAR_TELEPHONE_NUMBER, PR_COMPANY_NAME,
pr_mail1address, pr_mail1entryid, pr_mail1type, pr_mail1dispname,
pr_mail2address, pr_mail2entryid, pr_mail2type, pr_mail2dispname,
pr_mail3address, pr_mail3entryid, pr_mail3type, pr_mail3dispname, pr_fileas,
pr_fileasID, PR_GIVEN_NAME, PR_HOME_ADDRESS_CITY, PR_HOME_ADDRESS_COUNTRY,
PR_HOME_FAX_NUMBER, PR_HOME_TELEPHONE_NUMBER, PR_HOME2_TELEPHONE_NUMBER,
PR_HOME_ADDRESS_POSTAL_CODE, PR_HOME_ADDRESS_STATE_OR_PROVINCE,
PR_HOME_ADDRESS_STREET, PR_TITLE, PR_SURNAME, PR_MIDDLE_NAME,
PR_CELLULAR_TELEPHONE_NUMBER, PR_DISPLAY_NAME_PREFIX, PR_GENERATION,
// notes is PR_BODY and PR_BODY_HTML
PR_OTHER_ADDRESS_CITY, PR_OTHER_ADDRESS_COUNTRY, PR_PRIMARY_FAX_NUMBER, // other fax
PR_OTHER_TELEPHONE_NUMBER, PR_OTHER_ADDRESS_POSTAL_CODE,
PR_OTHER_ADDRESS_STATE_OR_PROVINCE, PR_OTHER_ADDRESS_STREET,
PR_PAGER_TELEPHONE_NUMBER, pr_business_address_city,
pr_business_address_country, PR_BUSINESS_FAX_NUMBER, PR_OFFICE_TELEPHONE_NUMBER,
pr_business_address_postal_code, pr_business_address_state,
pr_business_address_street, PR_BUSINESS_HOME_PAGE, PR_BIRTHDAY,
pr_contact_user1_idx, pr_contact_user2_idx, pr_contact_user3_idx,
pr_contact_user4_idx, pr_contact_oneoffmemebrs, pr_imaddress,
PR_WEDDING_ANNIVERSARY
}
};
ULONG cVals = 0;
if (FAILED(hr = m_pMessage->GetProps((LPSPropTagArray) & contactProps, fMapiUnicode, &cVals,
&m_pPropVals)))
throw MAPIContactException(hr, L"Init(): GetProps Failed.",
ERR_MAPI_CONTACT, __LINE__, __FILE__);
// see if there is a file-as id
LONG zimbraFileAsId = 0;
if (m_bPersonalDL) // PDL's always have a custom file-as
{
zimbraFileAsId = 8;
Type(L"group");
}
else if (m_pPropVals[C_FILEASID].ulPropTag == contactProps.aulPropTag[C_FILEASID])
{
switch (m_pPropVals[C_FILEASID].Value.l)
{
case OFA_LAST_C_FIRST:
zimbraFileAsId = 1;
break;
case OFA_FIRST_LAST:
zimbraFileAsId = 2;
break;
case OFA_COMPANY:
zimbraFileAsId = 3;
break;
case OFA_LAST_C_FIRST_COMPANY:
zimbraFileAsId = 4;
break;
case OFA_COMPANY_LAST_C_FIRST:
zimbraFileAsId = 6;
break;
case OFA_CUSTOM:
zimbraFileAsId = 8;
break;
}
}
// process all "String" properties
if (m_pPropVals[C_CALLBACK_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_CALLBACK_TELEPHONE_NUMBER])
CallbackPhone(m_pPropVals[C_CALLBACK_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_CAR_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_CAR_TELEPHONE_NUMBER])
CarPhone(m_pPropVals[C_CAR_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_COMPANY_NAME].ulPropTag == contactProps.aulPropTag[C_COMPANY_NAME])
Company(m_pPropVals[C_COMPANY_NAME].Value.lpszW);
if (m_pPropVals[C_FILEAS].ulPropTag == contactProps.aulPropTag[C_FILEAS])
{
if (zimbraFileAsId == 8)
{
LPWSTR pwszFileAsValue = m_pPropVals[C_FILEAS].Value.lpszW;
if ((pwszFileAsValue != NULL) && (wcsicmp(pwszFileAsValue, L"") != 0))
{
LPWSTR pwszTemp = new WCHAR[wcslen(m_pPropVals[C_FILEAS].Value.lpszW) + 3];
// there is a legit string for the custom fileas value
wsprintf(pwszTemp, L"8:%s", pwszFileAsValue);
FileAs(pwszTemp);
// PDL's require a nickname
if (m_bPersonalDL)
NickName(m_pPropVals[C_FILEAS].Value.lpszW);
delete[] pwszTemp;
}
else
{
LPWSTR pwszNONAME = new WCHAR[wcslen(L"NO_NAME") + 1];
wsprintf(pwszNONAME, L"%s", L"NO_NAME");
LPWSTR pwszTemp = new WCHAR[wcslen(pwszNONAME) + 3];
// there is a legit string for the custom fileas value
wsprintf(pwszTemp, L"8:%s", pwszNONAME);
FileAs(pwszTemp);
// PDL's require a nickname
if (m_bPersonalDL)
NickName(pwszNONAME);
delete[] pwszTemp;
delete[] pwszNONAME;
}
}
else if (zimbraFileAsId)
{
WCHAR pwszTemp[3];
_ltow(zimbraFileAsId, pwszTemp, 10);
FileAs(pwszTemp);
}
}
if (m_pPropVals[C_GIVEN_NAME].ulPropTag == contactProps.aulPropTag[C_GIVEN_NAME])
FirstName(m_pPropVals[C_GIVEN_NAME].Value.lpszW);
if (m_pPropVals[C_HOME_ADDRESS_CITY].ulPropTag ==
contactProps.aulPropTag[C_HOME_ADDRESS_CITY])
HomeCity(m_pPropVals[C_HOME_ADDRESS_CITY].Value.lpszW);
if (m_pPropVals[C_HOME_ADDRESS_COUNTRY].ulPropTag ==
contactProps.aulPropTag[C_HOME_ADDRESS_COUNTRY])
HomeCountry(m_pPropVals[C_HOME_ADDRESS_COUNTRY].Value.lpszW);
if (m_pPropVals[C_HOME_FAX_NUMBER].ulPropTag == contactProps.aulPropTag[C_HOME_FAX_NUMBER])
HomeFax(m_pPropVals[C_HOME_FAX_NUMBER].Value.lpszW);
if (m_pPropVals[C_HOME_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_HOME_TELEPHONE_NUMBER])
HomePhone(m_pPropVals[C_HOME_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_HOME2_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_HOME2_TELEPHONE_NUMBER])
HomePhone2(m_pPropVals[C_HOME2_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_HOME_ADDRESS_POSTAL_CODE].ulPropTag ==
contactProps.aulPropTag[C_HOME_ADDRESS_POSTAL_CODE])
HomePostalCode(m_pPropVals[C_HOME_ADDRESS_POSTAL_CODE].Value.lpszW);
if (m_pPropVals[C_HOME_ADDRESS_STATE_OR_PROVINCE].ulPropTag ==
contactProps.aulPropTag[C_HOME_ADDRESS_STATE_OR_PROVINCE])
HomeState(m_pPropVals[C_HOME_ADDRESS_STATE_OR_PROVINCE].Value.lpszW);
if (m_pPropVals[C_HOME_ADDRESS_STREET].ulPropTag ==
contactProps.aulPropTag[C_HOME_ADDRESS_STREET])
HomeStreet(m_pPropVals[C_HOME_ADDRESS_STREET].Value.lpszW);
if (m_pPropVals[C_TITLE].ulPropTag == contactProps.aulPropTag[C_TITLE])
JobTitle(m_pPropVals[C_TITLE].Value.lpszW);
if (m_pPropVals[C_SURNAME].ulPropTag == contactProps.aulPropTag[C_SURNAME])
LastName(m_pPropVals[C_SURNAME].Value.lpszW);
if (m_pPropVals[C_MIDDLE_NAME].ulPropTag == contactProps.aulPropTag[C_MIDDLE_NAME])
MiddleName(m_pPropVals[C_MIDDLE_NAME].Value.lpszW);
if (m_pPropVals[C_CELLULAR_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_CELLULAR_TELEPHONE_NUMBER])
MobilePhone(m_pPropVals[C_CELLULAR_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_DISPLAY_NAME_PREFIX].ulPropTag ==
contactProps.aulPropTag[C_DISPLAY_NAME_PREFIX])
NamePrefix(m_pPropVals[C_DISPLAY_NAME_PREFIX].Value.lpszW);
if (m_pPropVals[C_GENERATION].ulPropTag == contactProps.aulPropTag[C_GENERATION])
NameSuffix(m_pPropVals[C_GENERATION].Value.lpszW);
if (m_pPropVals[C_OTHER_ADDRESS_CITY].ulPropTag ==
contactProps.aulPropTag[C_OTHER_ADDRESS_CITY])
OtherCity(m_pPropVals[C_OTHER_ADDRESS_CITY].Value.lpszW);
if (m_pPropVals[C_OTHER_ADDRESS_COUNTRY].ulPropTag ==
contactProps.aulPropTag[C_OTHER_ADDRESS_COUNTRY])
OtherCountry(m_pPropVals[C_OTHER_ADDRESS_COUNTRY].Value.lpszW);
if (m_pPropVals[C_PRIMARY_FAX_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_PRIMARY_FAX_NUMBER])
OtherFax(m_pPropVals[C_PRIMARY_FAX_NUMBER].Value.lpszW);
if (m_pPropVals[C_OTHER_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_OTHER_TELEPHONE_NUMBER])
OtherPhone(m_pPropVals[C_OTHER_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_OTHER_ADDRESS_POSTAL_CODE].ulPropTag ==
contactProps.aulPropTag[C_OTHER_ADDRESS_POSTAL_CODE])
OtherPostalCode(m_pPropVals[C_OTHER_ADDRESS_POSTAL_CODE].Value.lpszW);
if (m_pPropVals[C_OTHER_ADDRESS_STATE_OR_PROVINCE].ulPropTag ==
contactProps.aulPropTag[C_OTHER_ADDRESS_STATE_OR_PROVINCE])
OtherState(m_pPropVals[C_OTHER_ADDRESS_STATE_OR_PROVINCE].Value.lpszW);
if (m_pPropVals[C_OTHER_ADDRESS_STREET].ulPropTag ==
contactProps.aulPropTag[C_OTHER_ADDRESS_STREET])
OtherStreet(m_pPropVals[C_OTHER_ADDRESS_STREET].Value.lpszW);
if (m_pPropVals[C_PAGER_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_PAGER_TELEPHONE_NUMBER])
Pager(m_pPropVals[C_PAGER_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_BUSINESS_ADDRESS_CITY].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_ADDRESS_CITY])
WorkCity(m_pPropVals[C_BUSINESS_ADDRESS_CITY].Value.lpszW);
if (m_pPropVals[C_BUSINESS_ADDRESS_COUNTRY].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_ADDRESS_COUNTRY])
WorkCountry(m_pPropVals[C_BUSINESS_ADDRESS_COUNTRY].Value.lpszW);
if (m_pPropVals[C_BUSINESS_FAX_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_FAX_NUMBER])
WorkFax(m_pPropVals[C_BUSINESS_FAX_NUMBER].Value.lpszW);
if (m_pPropVals[C_OFFICE_TELEPHONE_NUMBER].ulPropTag ==
contactProps.aulPropTag[C_OFFICE_TELEPHONE_NUMBER])
WorkPhone(m_pPropVals[C_OFFICE_TELEPHONE_NUMBER].Value.lpszW);
if (m_pPropVals[C_BUSINESS_ADDRESS_POSTAL_CODE].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_ADDRESS_POSTAL_CODE])
WorkPostalCode(m_pPropVals[C_BUSINESS_ADDRESS_POSTAL_CODE].Value.lpszW);
if (m_pPropVals[C_BUSINESS_ADDRESS_STATE].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_ADDRESS_STATE])
WorkState(m_pPropVals[C_BUSINESS_ADDRESS_STATE].Value.lpszW);
if (m_pPropVals[C_BUSINESS_ADDRESS_STREET].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_ADDRESS_STREET])
WorkStreet(m_pPropVals[C_BUSINESS_ADDRESS_STREET].Value.lpszW);
if (m_pPropVals[C_BUSINESS_HOME_PAGE].ulPropTag ==
contactProps.aulPropTag[C_BUSINESS_HOME_PAGE])
WorkURL(m_pPropVals[C_BUSINESS_HOME_PAGE].Value.lpszW);
if (m_pPropVals[C_CONTACT_USER1_IDX].ulPropTag ==
contactProps.aulPropTag[C_CONTACT_USER1_IDX])
UserField1(m_pPropVals[C_CONTACT_USER1_IDX].Value.lpszW);
if (m_pPropVals[C_CONTACT_USER2_IDX].ulPropTag ==
contactProps.aulPropTag[C_CONTACT_USER2_IDX])
UserField2(m_pPropVals[C_CONTACT_USER2_IDX].Value.lpszW);
if (m_pPropVals[C_CONTACT_USER3_IDX].ulPropTag ==
contactProps.aulPropTag[C_CONTACT_USER3_IDX])
UserField3(m_pPropVals[C_CONTACT_USER3_IDX].Value.lpszW);
if (m_pPropVals[C_CONTACT_USER4_IDX].ulPropTag ==
contactProps.aulPropTag[C_CONTACT_USER4_IDX])
UserField4(m_pPropVals[C_CONTACT_USER4_IDX].Value.lpszW);
if (m_pPropVals[C_BIRTHDAY].ulPropTag == contactProps.aulPropTag[C_BIRTHDAY])
{
SYSTEMTIME st = { 0 };
FileTimeToSystemTime(&(m_pPropVals[C_BIRTHDAY].Value.ft), &st);
// We get PR_BIRTHDAY in UTC so let's convert it into local time
TIME_ZONE_INFORMATION tzInfo = { 0 };
GetTimeZoneInformation(&tzInfo);
SystemTimeToTzSpecificLocalTime(&tzInfo, &st, &st);
TCHAR pszBDay[11];
swprintf(pszBDay, 11, _T("%4d-%02d-%02d"), st.wYear, st.wMonth, st.wDay);
Birthday(pszBDay);
}
if (m_pPropVals[C_ANNIVERSARY].ulPropTag == contactProps.aulPropTag[C_ANNIVERSARY])
{
SYSTEMTIME st = { 0 };
FileTimeToSystemTime(&(m_pPropVals[C_ANNIVERSARY].Value.ft), &st);
// We get PR_ANNIVERSARY in UTC so let's convert it into local time
TIME_ZONE_INFORMATION tzInfo = { 0 };
GetTimeZoneInformation(&tzInfo);
SystemTimeToTzSpecificLocalTime(&tzInfo, &st, &st);
TCHAR pszAnniv[11];
swprintf(pszAnniv, 11, _T("%4d-%02d-%02d"), st.wYear, st.wMonth, st.wDay);
Anniversary(pszAnniv);
}
// email 1
RECIP_INFO tempRecip;
if ((m_pPropVals[C_MAIL1TYPE].ulPropTag == contactProps.aulPropTag[C_MAIL1TYPE]) &&
(m_pPropVals[C_MAIL1ADDRESS].ulPropTag == contactProps.aulPropTag[C_MAIL1ADDRESS]))
{
if (wcscmp(m_pPropVals[C_MAIL1TYPE].Value.lpszW, L"SMTP") == 0)
{
Email(m_pPropVals[C_MAIL1ADDRESS].Value.lpszW);
}
else if (wcscmp(m_pPropVals[C_MAIL1TYPE].Value.lpszW, L"EX") == 0)
{
tempRecip.pAddrType = m_pPropVals[C_MAIL1TYPE].Value.lpszW;
tempRecip.pEmailAddr = m_pPropVals[C_MAIL1ADDRESS].Value.lpszW;
tempRecip.cbEid = m_pPropVals[C_MAIL1EID].Value.bin.cb;
tempRecip.pEid = (LPENTRYID)(m_pPropVals[C_MAIL1EID].Value.bin.lpb);
wstring strSenderEmail(_TEXT(""));
HRESULT hr = Zimbra::MAPI::Util::HrMAPIGetSMTPAddress(*m_session, tempRecip,
strSenderEmail);
if (hr != S_OK)
Email(m_pPropVals[C_MAIL1DISPNAME].Value.lpszW);
else
Email((LPTSTR)strSenderEmail.c_str());
}
}
// email 2
if ((m_pPropVals[C_MAIL2TYPE].ulPropTag == contactProps.aulPropTag[C_MAIL2TYPE]) &&
(m_pPropVals[C_MAIL2ADDRESS].ulPropTag == contactProps.aulPropTag[C_MAIL2ADDRESS]))
{
if (wcscmp(m_pPropVals[C_MAIL2TYPE].Value.lpszW, L"SMTP") == 0)
{
Email2(m_pPropVals[C_MAIL2ADDRESS].Value.lpszW);
}
else if (wcscmp(m_pPropVals[C_MAIL2TYPE].Value.lpszW, L"EX") == 0)
{
tempRecip.pAddrType = m_pPropVals[C_MAIL2TYPE].Value.lpszW;
tempRecip.pEmailAddr = m_pPropVals[C_MAIL2ADDRESS].Value.lpszW;
tempRecip.cbEid = m_pPropVals[C_MAIL2EID].Value.bin.cb;
tempRecip.pEid = (LPENTRYID)(m_pPropVals[C_MAIL2EID].Value.bin.lpb);
wstring strSenderEmail(_TEXT(""));
HRESULT hr = Zimbra::MAPI::Util::HrMAPIGetSMTPAddress(*m_session, tempRecip,
strSenderEmail);
if (hr != S_OK)
Email(m_pPropVals[C_MAIL2DISPNAME].Value.lpszW);
else
Email2((LPTSTR)strSenderEmail.c_str());
}
}
// email 3
if ((m_pPropVals[C_MAIL3TYPE].ulPropTag == contactProps.aulPropTag[C_MAIL3TYPE]) &&
(m_pPropVals[C_MAIL3ADDRESS].ulPropTag == contactProps.aulPropTag[C_MAIL3ADDRESS]))
{
if (wcscmp(m_pPropVals[C_MAIL3TYPE].Value.lpszW, L"SMTP") == 0)
{
Email3(m_pPropVals[C_MAIL3ADDRESS].Value.lpszW);
}
else if (wcscmp(m_pPropVals[C_MAIL3TYPE].Value.lpszW, L"EX") == 0)
{
tempRecip.pAddrType = m_pPropVals[C_MAIL3TYPE].Value.lpszW;
tempRecip.pEmailAddr = m_pPropVals[C_MAIL3ADDRESS].Value.lpszW;
tempRecip.cbEid = m_pPropVals[C_MAIL3EID].Value.bin.cb;
tempRecip.pEid = (LPENTRYID)(m_pPropVals[C_MAIL3EID].Value.bin.lpb);
wstring strSenderEmail(_TEXT(""));
HRESULT hr = Zimbra::MAPI::Util::HrMAPIGetSMTPAddress(*m_session, tempRecip,
strSenderEmail);
if (hr != S_OK)
Email(m_pPropVals[C_MAIL3DISPNAME].Value.lpszW);
else
Email3((LPTSTR)strSenderEmail.c_str());
}
}
if (m_pPropVals[C_IMADDRESS].ulPropTag == contactProps.aulPropTag[C_IMADDRESS])
IMAddress1(m_pPropVals[C_IMADDRESS].Value.lpszW);
// add the 'notes' section
if (m_mapiMessage->HasTextPart())
{
LPTSTR pBody = NULL;
UINT nText = 0;
m_mapiMessage->TextBody(&pBody, nText);
LPTSTR psz = pBody;
if (psz)
{
const char SPACE = ' ', TAB = '\t', CR = 0x0d, LF = 0x0a;
while (*psz)
{
// Replace control characters with space
// Exclude carriage return and new line characters while doing the same
if ((*psz < SPACE) && (*psz != CR) && (*psz != LF))
*psz = _T(' ');
psz++;
}
// We'll add the body only if it has data other than white spaces and new lines
bool bHasValidChars = false;
psz = pBody;
while (*psz)
{
if ((*psz == SPACE) || (*psz == TAB) || (*psz == CR) || (*psz == LF))
{
psz++;
continue;
}
else
{
bHasValidChars = true;
break;
}
}
if (bHasValidChars)
Notes(pBody);
MAPIFreeBuffer(pBody);
}
}
// if its a distribution list, add the dist list members to the property
wstring strInvalidGroupContacts;
if (m_bPersonalDL)
{
std::wstring dlist = L"";
if (m_pPropVals[C_ONEOFFMEMEBRS_IDX].ulPropTag ==
contactProps.aulPropTag[C_ONEOFFMEMEBRS_IDX])
{
bool bFirst = true;
for (ULONG i = 0; i < m_pPropVals[C_ONEOFFMEMEBRS_IDX].Value.MVbin.cValues; i++)
{
DWORD dwObjType;
SBinary &bin = m_pPropVals[C_ONEOFFMEMEBRS_IDX].Value.MVbin.lpbin[i];
IMailUser *pUser = NULL;
hr = m_session->OpenEntry(bin.cb, (LPENTRYID)bin.lpb, NULL, 0, &dwObjType,
(LPUNKNOWN *)&pUser);
if (FAILED(hr) || !pUser)
continue;
LPSPropValue pDNProp = NULL;
LPSPropValue pAddrProp = NULL;
std::wstring user = L"";
BOOL bIsInvalidContact = TRUE;
HrGetOneProp(pUser, PR_DISPLAY_NAME_W, &pDNProp);
HrGetOneProp(pUser, PR_EMAIL_ADDRESS_W, &pAddrProp);
if (pDNProp && (pDNProp->ulPropTag == PR_DISPLAY_NAME_W) && wcslen(
pDNProp->Value.lpszW))
user += pDNProp->Value.lpszW;
if (pAddrProp && (pAddrProp->ulPropTag == PR_EMAIL_ADDRESS_W) && wcslen(
pAddrProp->Value.lpszW))
{
std::wstring temp = pAddrProp->Value.lpszW;
if (temp.find(L'@') != std::wstring::npos)
bIsInvalidContact = FALSE;
if (!user.empty())
user += L" ";
user += L"<";
user += temp;
user += L">";
}
if (bIsInvalidContact)
{
if (!user.empty())
{
if (!strInvalidGroupContacts.empty())
strInvalidGroupContacts += _T(", ");
strInvalidGroupContacts += user.c_str();
}
}
else
{
if (bFirst)
bFirst = false;
else
dlist += L",";
dlist += user;
}
pUser->Release();
MAPIFreeBuffer(pDNProp);
MAPIFreeBuffer(pAddrProp);
}
}
//set DL values
DList((LPTSTR)dlist.c_str());
}
//user define props
if (!m_bPersonalDL)
{
LPMAPINAMEID FAR *lppPropNames = NULL;
LPSPropTagArray tagArray;
ULONG lCount = 0;
hr = m_pMessage->GetPropList(MAPI_UNICODE, &tagArray);
if (hr == S_OK)
{
hr = m_pMessage->GetNamesFromIDs(&tagArray, (LPGUID)&PS_PUBLIC_STRINGS, 0, &lCount,
&lppPropNames);
if (SUCCEEDED(hr))
{
WCHAR wszProps2GUID[40] = { 0 };
Zimbra::Util::Guid nameProps2Guid(OUTLOOK_NAME_PROPS_GUID_2);
nameProps2Guid.toString(wszProps2GUID);
WCHAR wszContactPropGUID[40] = { 0 };
WCHAR wszVal[1024]={0};
for (ULONG i = 0; i < lCount; i++)
{
Zimbra::Util::ScopedBuffer<SPropValue> pPropVal;
hr = HrGetOneProp(m_pMessage, tagArray->aulPropTag[i], pPropVal.getptr());
if (lppPropNames[i] != NULL) // FBS bug 71786 -- 3/20/12
{
if (lppPropNames[i]->ulKind == MNID_STRING)
{
Zimbra::Util::Guid propGuid(*lppPropNames[i]->lpguid);
propGuid.toString(wszContactPropGUID);
if (lstrcmpiW(wszContactPropGUID, wszProps2GUID) == 0)
{
LPWSTR szPropName = lppPropNames[i]->Kind.lpwstrName;
// now format a string depending on the type
ULONG ulPropType = PROP_TYPE(pPropVal->ulPropTag);
BOOL bSetAttribute = TRUE;
switch (ulPropType)
{
case PT_UNICODE:
wcscpy(wszVal, pPropVal->Value.lpszW);
break;
case PT_SYSTIME:
{
SYSTEMTIME sysTime = { 0 };
if (FileTimeToSystemTime(&(pPropVal->Value.ft), &sysTime))
{
TIME_ZONE_INFORMATION tzInfo = { 0 };
GetTimeZoneInformation(&tzInfo);
SystemTimeToTzSpecificLocalTime(&tzInfo, &sysTime, &sysTime);
wsprintf(wszVal, L"%4d-%02d-%02d", sysTime.wYear,
sysTime.wMonth, sysTime.wDay);
}
break;
}
case PT_LONG:
wsprintf(wszVal, L"%d", pPropVal->Value.l);
break;
case PT_DOUBLE:
{
CHAR tmp[36];
_gcvt(pPropVal->Value.dbl, 6, tmp);
LPWSTR wszTmp = Zimbra::Util::AnsiiToUnicode(tmp);
wcscpy(wszVal, wszTmp);
break;
}
case PT_BOOLEAN:
if (pPropVal->Value.b)
wcscpy(wszVal, L"TRUE");
else
wcscpy(wszVal, L"FALSE");
break;
case PT_CURRENCY:
{
LONGLONG lCurrency;
CURRENCY currency;
currency = pPropVal->Value.cur;
lCurrency = currency.int64;
lCurrency = lCurrency / 10000;
wsprintf(wszVal, L"$%I64d", lCurrency);
break;
}
default: // can't deal with these other types
bSetAttribute = FALSE;
//LOG("%hs: MAPI type %0x not supported: user defined field %s will not be synced"),
// __FUNCTION__, ulPropType, szPropName);
}
ContactUDFields cudf;
cudf.Name = szPropName;
cudf.value = wszVal;
AddUserDefinedField(cudf);
}
}
}
}
MAPIFreeBuffer(lppPropNames);
}
MAPIFreeBuffer(tagArray);
}
}
// Save image path
wstring wstrImagePath,wstrContentType,wstrContentDisp;
if (m_mapiMessage->HasAttach())
{
if (!FAILED(hr = GetContactImage(wstrImagePath,wstrContentType,wstrContentDisp)))
{
ContactImagePath((LPTSTR)wstrImagePath.c_str());
ContactImageType((LPTSTR)wstrContentType.c_str());
ContactImageDisp((LPTSTR)wstrContentDisp.c_str());
}
}
return S_OK;
}
void MessageReceiverBase::MessageReceiverBase()
{
m_ModuleMessageManager = GetModule(Type("ModuleMessageManager"));
}
istream& SGOfFreeNilpotentGroupRep::readIPC( istream& s) const {
SGOfFreeNilpotentGroupRep* This = (SGOfFreeNilpotentGroupRep*) this;
SGOfNilpotentGroupRep::readIPC(s);
s > This->theParentGroup > This->theGenerators > This->theBasis
> This->theBasisNames > This->theBasisSet;
return s;
}
Chars SGOfFreeNilpotentGroupRep::asDecomposition( const PolyWord& w ) const {
if( ! basisIsInitialized() )
error("SGOfFreeNilpotentGroupRep::asDecomposition: the basis must be built");
return w.toChars( theBasisNames );
}
GenericRep* SGOfFreeNilpotentGroupRep::clone( ) const {
return new SGOfFreeNilpotentGroupRep(*this);
}
const Type SGOfFreeNilpotentGroupRep::theSGOfFreeNilpotentGroupType =
Type( Type::unique() );
void
DLVertex :: Load ( SaveLoadManager& m )
{
// now OP is already loaded
switch ( Type() )
{
case dtBad:
case dtTop: // can't be S/L
default:
fpp_unreachable();
break;
case dtAnd:
{
unsigned int size = m.loadUInt();
for ( unsigned int j = 0; j < size; ++j )
Child.push_back(m.loadSInt());
break;
}
case dtLE:
Role = static_cast<const TRole*>(m.loadEntry());
setChild(m.loadSInt());
n = m.loadUInt();
break;
case dtForall:
Role = static_cast<const TRole*>(m.loadEntry());
setChild(m.loadSInt());
n = m.loadUInt();
break;
case dtIrr:
Role = static_cast<const TRole*>(m.loadEntry());
break;
case dtPConcept:
case dtNConcept:
case dtPSingleton:
case dtNSingleton:
setConcept(m.loadEntry());
setChild(m.loadSInt());
break;
case dtProj:
setChild(m.loadSInt());
Role = static_cast<const TRole*>(m.loadEntry());
ProjRole = static_cast<const TRole*>(m.loadEntry());
break;
case dtNN: // nothing to do
break;
case dtDataType:
case dtDataValue:
case dtDataExpr:
setConcept(m.loadEntry());
setChild(m.loadSInt());
break;
}
}
