1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
|
#if !defined(HISTORYSTATS_GUARD_MU_COMMON_H)
#define HISTORYSTATS_GUARD_MU_COMMON_H
/*
* mu = miranda unified services
*/
#define _WIN32_WINDOWS 0x0500 // for WM_MOUSEWHEEL
#define _WIN32_WINNT 0x0501 // for WM_THEMECHANGED
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
/*
* include miranda headers
*/
#define MIRANDA_VER 0x0600
#include <miranda/newpluginapi.h>
#include <miranda/m_awaymsg.h> // not used
#include <miranda/m_button.h> // not used
#include <miranda/m_chat.h> // not used
#include <miranda/m_clc.h>
#include <miranda/m_clist.h>
#include <miranda/m_clistint.h> // not used
#include <miranda/m_clui.h> // not used
#include <miranda/m_contactdir.h> // not used
#include <miranda/m_contacts.h>
#include <miranda/m_database.h>
#include <miranda/m_email.h> // not used
#include <miranda/m_file.h> // not used
#include <miranda/m_findadd.h> // not used
#include <miranda/m_fontservice.h> // not used
#include <miranda/m_fuse.h> // not used
#include <miranda/m_genmenu.h> // not used
#include <miranda/m_history.h> // not used
#include <miranda/m_icolib.h>
#include <miranda/m_idle.h> // not used
#include <miranda/m_ignore.h> // not used
#include <miranda/m_langpack.h>
#include <miranda/m_message.h> // not used
#include <miranda/m_netlib.h> // not used
#include <miranda/m_options.h>
#include <miranda/m_plugins.h> // not used
#include <miranda/m_png.h>
#include <miranda/m_popup.h> // not used
#include <miranda/m_protocols.h>
#include <miranda/m_protomod.h> // not used
#include <miranda/m_protosvc.h>
#include <miranda/m_skin.h>
#include <miranda/m_system.h>
#include <miranda/m_system_cpp.h> // not used
#include <miranda/m_url.h> // not used
#include <miranda/m_userinfo.h> // not used
#include <miranda/m_utils.h>
#include <miranda/m_addcontact.h> // not used, depends on m_protosvc.h
#include <miranda/m_icq.h> // depends on m_protosvc.h
#include "include/m_updater.h"
#include "include/m_metacontacts.h"
#include "include/m_historystats.h" // our own header
/*
* undefine macros that pollute our namespace
*/
// from above
#undef MIRANDA_VER
// from newpluginapi.h
#undef CreateHookableEvent
#undef DestroyHookableEvent
#undef NotifyEventHooks
#undef HookEventMessage
#undef HookEvent
#undef UnhookEvent
#undef CreateServiceFunction
#undef CreateTransientServiceFunction
#undef DestroyServiceFunction
#undef CallService
#undef ServiceExists
#undef CallServiceSync
#undef CallFunctionAsync
#undef SetHookDefaultForHookableEvent
#undef CreateServiceFunctionParam
#undef NotifyEventHooksDirect
// from m_database.h
#undef db_byte_get
#undef db_word_get
#undef db_dword_get
#undef db_get
#undef db_byte_set
#undef db_word_set
#undef db_dword_set
#undef db_string_set
#undef db_unset
#undef DBGetContactSettingByte
#undef DBGetContactSettingWord
#undef DBGetContactSettingDword
#undef DBGetContactSetting
#undef DBGetContactSettingString
#undef DBGetContactSettingWString
#undef DBGetContactSettingUTF8String
#undef DBGetContactSettingTString
#undef db_msg_dbg
#undef DBGetContactSettingStringUtf
#undef DBWriteContactSettingStringUtf
#undef DBGetContactSettingW
// from m_langpack.h
#undef Translate
#undef TranslateW
#undef TranslateT
#undef TranslateTS
// from m_popup.h
#undef PUAddPopUpT
#undef PUChangeTextT
#undef PUChangeT
#undef ShowClassPopupT
// from m_system.h
#undef mir_alloc
#undef mir_free
#undef mir_realloc
#undef mir_calloc
#undef mir_strdup
#undef mir_wstrdup
#undef mir_snprintf
#undef mir_sntprintf
#undef mir_vsnprintf
#undef mir_vsntprintf
#undef mir_a2u_cp
#undef mir_a2u
#undef mir_u2a_cp
#undef mir_u2a
#undef mir_tstrdup
#undef miranda_sys_free
#undef memoryManagerInterface
#undef mir_utf8decode
#undef mir_utf8decodecp
#undef mir_utf8decodeW
#undef mir_utf8encode
#undef mir_utf8encodecp
#undef mir_utf8encodeW
#undef mir_utf8encodeT
// from m_utils.h
#undef mir_md5_init
#undef mir_md5_append
#undef mir_md5_finish
#undef mir_md5_hash
#undef mir_sha1_init
#undef mir_sha1_append
#undef mir_sha1_finish
#undef mir_sha1_hash
#undef TCHAR_STR_PARAM
#undef mir_t2a
#undef mir_a2t
#undef mir_t2u
#undef mir_u2t
#undef mir_t2a_cp
#undef mir_a2t_cp
#undef mir_t2u_cp
#undef mir_u2t_cp
/*
* basic defines
*/
#if defined(_UNICODE)
#undef MU_ANSI
#define MU_WIDE
#else
#define MU_ANSI
#undef MU_WIDE
#endif
/*
* helper macros to avoid many "#if defined(MU_WIDE) ... #else ... #endif" constructs
*/
#if defined(MU_WIDE)
#define MU_DO_BOTH(ansi, wide) wide
#define MU_DO_WIDE(wide) wide
#define MU_DO_ANSI(ansi) (void) 0
#else
#define MU_DO_BOTH(ansi, wide) ansi
#define MU_DO_WIDE(wide) (void) 0
#define MU_DO_ANSI(ansi) ansi
#endif
/*
* common types mu_wide/mu_ansi/mu_text
*/
typedef wchar_t mu_wide;
typedef char mu_ansi;
typedef MU_DO_BOTH(char, wchar_t) mu_text;
/*
* common macros for wrapping text
*/
#define muC(x) x
#define muW(x) L##x
#define muA(x) x
#define muT(x) MU_DO_BOTH(muA(x), muW(x))
/*
* helper functions
*/
namespace mu
{
/*
* clist
*/
namespace clist
{
HANDLE addMainMenuItem(const mu_text* pszName, DWORD flags, int position, HICON hIcon, const mu_ansi* pszService, const mu_text* pszPopupName = NULL, int popupPosition = 0, DWORD hotKey = 0);
HANDLE addContactMenuItem(const mu_text* pszName, DWORD flags, int position, HICON hIcon, const mu_ansi* pszService, DWORD hotKey = 0, const mu_ansi* pszContactOwner = NULL);
int modifyMenuItem(HANDLE hMenuItem, DWORD toModify, const mu_text* pszName = NULL, DWORD flags = 0, HICON hIcon = NULL, DWORD hotKey = 0);
const mu_text* getContactDisplayName(HANDLE hContact);
const mu_text* getStatusModeDescription(int nStatusMode);
}
/*
* db
*/
namespace db
{
int getProfilePath(int cbName, mu_text* pszName);
int getProfileName(int cbName, mu_text* pszName);
void setSafetyMode(bool safetyMode);
}
/*
* db_contact
*/
namespace db_contact
{
int getSetting(HANDLE hContact, const mu_ansi* szModule, const mu_ansi* szSetting, DBVARIANT* dbv);
int getSettingStr(HANDLE hContact, const mu_ansi* szModule, const mu_ansi* szSetting, DBVARIANT* dbv);
int freeVariant(DBVARIANT* dbv);
int writeSetting(HANDLE hContact, DBCONTACTWRITESETTING* dbcws);
int deleteSetting(HANDLE hContact, const mu_ansi* szModule, const mu_ansi* szSetting);
int enumSettings(HANDLE hContact, const mu_ansi* szModule, DBSETTINGENUMPROC pEnumProc, LPARAM lProcParam);
int getCount();
HANDLE findFirst();
HANDLE findNext(HANDLE hContact);
}
/*
* db_event
*/
namespace db_event
{
HANDLE add(HANDLE hContact, DBEVENTINFO* dbe);
int getBlobSize(HANDLE hDbEvent);
int get(HANDLE hDbEvent, DBEVENTINFO* dbe);
HANDLE findFirst(HANDLE hContact);
HANDLE findNext(HANDLE hDbEvent);
}
/*
* db_time
*/
namespace db_time
{
DWORD timestampToLocal(DWORD timestamp);
}
/*
* icolib
*/
namespace icolib
{
bool _available();
void addIcon(const mu_text* szSection, const mu_text* szDescription, const mu_ansi* szIconName, const mu_ansi* szDefaultFile, int iDefaultIndex, int cx = 16, int cy = 16);
void addIcon(const mu_text* szSection, const mu_text* szDescription, const mu_ansi* szIconName, HICON hDefaultIcon, int cx = 16, int cy = 16);
HICON getIcon(const mu_ansi* szIconName);
}
/*
* langpack
*/
namespace langpack
{
int translateDialog(HWND hwndDlg, DWORD flags = 0, const int* ignoreControls = NULL);
const mu_text* translateString(const mu_text* szEnglish);
UINT getCodePage();
}
/*
* metacontacts [external]
*/
namespace metacontacts
{
bool _available();
HANDLE getMetaContact(HANDLE hSubContact);
int getNumContacts(HANDLE hMetaContact);
HANDLE getSubContact(HANDLE hMetaContact, int iContactNumber);
const mu_ansi* getProtocolName();
}
/*
* opt
*/
namespace opt
{
void addPage(WPARAM addInfo, const mu_text* pszGroup, const mu_text* pszTitle, const mu_text* pszTab, DLGPROC pfnDlgProc, const mu_ansi* pszTemplate, HINSTANCE hInstance, DWORD flags = ODPF_BOLDGROUPS);
}
/*
* png
*/
namespace png
{
bool _available();
bool dibToPng(const BITMAPINFOHEADER* pBMIH, const BYTE* pDIData, BYTE* pImageData, long* pImageLen);
}
/*
* proto
*/
namespace proto
{
int enumProtocols(int* numProtocols, PROTOCOLDESCRIPTOR*** ppProtoDescriptors);
const mu_ansi* getContactBaseProto(HANDLE hContact);
}
/*
* protosvc
*/
namespace protosvc
{
DWORD getCaps(const mu_ansi* szProto, int flagNum);
int getName(const mu_ansi* szProto, int cchName, mu_text* szName);
HICON loadIcon(const mu_ansi* szProto, int whichIcon);
}
/*
* sha1
*/
namespace sha1
{
bool _available();
SHA1_INTERFACE getInterface();
}
/*
* skin
*/
namespace skin
{
HICON loadIcon(int id);
}
/*
* system
*/
namespace system
{
DWORD getVersion();
int getVersionText(int cchVersion, mu_ansi* szVersion);
void threadPush();
void threadPop();
int terminated();
}
/*
* updater [external]
*/
namespace updater
{
bool _available();
void registerFL(int fileID, const PLUGININFO* pluginInfo);
}
/*
* utils
*/
namespace utils
{
int pathToRelative(const mu_text* pszPath, mu_text* pszNewPath);
int pathToAbsolute(const mu_text* pszPath, mu_text* pszNewPath);
}
/*
* _link
*/
namespace _link
{
extern PLUGINLINK* g_pLink;
inline HANDLE createHookableEvent(const char* szEvent) { return g_pLink->CreateHookableEvent(szEvent); }
inline int destroyHookableEvent(HANDLE hEvent) { return g_pLink->DestroyHookableEvent(hEvent); }
inline int notifyEventHooks(HANDLE hEvent, WPARAM wParam, LPARAM lParam) { return g_pLink->NotifyEventHooks(hEvent, wParam, lParam); }
inline HANDLE hookEvent(const char* szEvent, MIRANDAHOOK pHookFunc) { return g_pLink->HookEvent(szEvent, pHookFunc); }
inline HANDLE hookEventMessage(const char* szEvent, HWND hWnd, UINT uData) { return g_pLink->HookEventMessage(szEvent, hWnd, uData); }
inline int unhookEvent(HANDLE hEvent) { return (hEvent ? g_pLink->UnhookEvent(hEvent) : 0); }
inline HANDLE createServiceFunction(const char* szService, MIRANDASERVICE pServiceFunc) { return g_pLink->CreateServiceFunction(szService, pServiceFunc); }
inline HANDLE createTransientServiceFunction(const char* szService, MIRANDASERVICE pServiceFunc) { return g_pLink->CreateTransientServiceFunction(szService, pServiceFunc); }
inline int destroyServiceFunction(HANDLE hService) { return g_pLink->DestroyServiceFunction(hService); }
inline int callService(const char* szService, WPARAM wParam, LPARAM lParam) { return g_pLink->CallService(szService, wParam, lParam); }
inline int serviceExists(const char* szService) { return g_pLink->ServiceExists(szService); }
inline int callServiceSync(const char* szService, WPARAM wParam, LPARAM lParam) { return g_pLink->CallServiceSync(szService, wParam, lParam); }
inline int callFunctionAsync(void (__stdcall* pFunc)(void*), void* pData) { return g_pLink->CallFunctionAsync(pFunc, pData); }
inline int setHookDefaultForHookableEvent(HANDLE hEvent, MIRANDAHOOK pHookFunc) { return g_pLink->SetHookDefaultForHookableEvent(hEvent, pHookFunc); }
inline HANDLE createServiceFunctionParam(const char* szService, MIRANDASERVICEPARAM pServiceFunc, LPARAM lParam) { return g_pLink->CreateServiceFunctionParam(szService, pServiceFunc, lParam); }
inline int notifyEventHooksDirect(HANDLE hEvent, WPARAM wParam, LPARAM lParam) { return g_pLink->NotifyEventHooksDirect(hEvent, wParam, lParam); }
int callProtoService(const char* szModule, const char* szService, WPARAM wParam, LPARAM lParam);
}
/*
* memory handling
*/
void* mirAlloc(size_t size);
void* mirRealloc(void* memblock, size_t size);
void mirFree(void* memblock);
/*
* core interface functions
*/
bool load(PLUGINLINK* pLink);
void unload();
DWORD getMinimalMirandaVersion();
bool isMirandaVersionOk(DWORD version);
bool isMirandaUnicode();
/*
* string handling
*/
mu_ansi* wideToAnsiDup(const mu_wide* pszWide, UINT uCP = CP_ACP);
mu_wide* ansiToWideDup(const mu_ansi* pszAnsi, UINT uCP = CP_ACP);
mu_ansi* wideToAnsi(const mu_wide* pszWide, mu_ansi* pszRes, int maxLen, UINT uCP = CP_ACP);
mu_wide* ansiToWide(const mu_ansi* pszAnsi, mu_wide* pszRes, int maxLen, UINT uCP = CP_ACP);
inline void freeWide(mu_wide* pszWide) { free(pszWide); }
inline void freeAnsi(mu_ansi* pszAnsi) { free(pszAnsi); }
}
#endif // HISTORYSTATS_GUARD_MU_COMMON_H
|
