Changeset 1757

Show
Ignore:
Timestamp:
02/19/07 11:36:40 (22 months ago)
Author:
mjahn
Message:

***Warning the current state is not usefull and will not build!***
- fix changetypes api
- add kde_discover (copy&pasted form evo2sync)
- mostly fixed api changes
- disabled event, todo and notes

Location:
plugins/kdepim
Files:
7 modified

Legend:

Unmodified
Added
Removed
  • plugins/kdepim/Makefile.am

    r1292 r1757  
    3737kdepim_sync_la_LIBADD = -lstdc++ -L@OPENSYNC_LIBDIR@ -lopensync 
    3838 
    39 src/kdepim_impl.cpp: KNotesIface_stub.h 
    40 KNotesIface_stub.cpp: KNotesIface_stub.h 
     39#src/kdepim_impl.cpp: KNotesIface_stub.h 
     40#KNotesIface_stub.cpp: KNotesIface_stub.h 
    4141 
    42 KNotesIface_stub.cpp: 
    43         dcopidl $(top_srcdir)/src/KNotesIface.h > KNotesIface.kidl 
    44         dcopidl2cpp KNotesIface.kidl 
    45 KNotesIface_stub.h: 
    46         dcopidl $(top_srcdir)/src/KNotesIface.h > KNotesIface.kidl 
    47         dcopidl2cpp KNotesIface.kidl 
     42#KNotesIface_stub.cpp: 
     43#       dcopidl $(top_srcdir)/src/KNotesIface.h > KNotesIface.kidl 
     44#       dcopidl2cpp KNotesIface.kidl 
     45#KNotesIface_stub.h: 
     46#       dcopidl $(top_srcdir)/src/KNotesIface.h > KNotesIface.kidl 
     47#       dcopidl2cpp KNotesIface.kidl 
    4848 
    49 dist_kdepim_lib_la_SOURCES = \ 
    50         src/kdepim_impl.cpp \ 
    51         src/kcal.cpp \ 
    52         src/knotes.cpp \ 
    53         src/kaddrbook.cpp  
    54 nodist_kdepim_lib_la_SOURCES = KNotesIface_stub.cpp 
     49dist_kdepim_lib_la_SOURCES = src/kdepim_impl.cpp src/kaddrbook.cpp 
     50#       src/kdepim_impl.cpp \ 
     51#       src/kcal.cpp \ 
     52#       src/knotes.cpp \ 
     53#       src/kaddrbook.cpp  
     54#nodist_kdepim_lib_la_SOURCES = KNotesIface_stub.cpp 
    5555kdepim_lib_la_CXXFLAGS = -DPLUGINDIR=\"$(plugindir)\" -DKDEPIM_LIBDIR=\"$(plugindir)\" -Wall 
    5656kdepim_lib_la_LDFLAGS = $(KDE_LDFLAGS) -avoid-version -export-dynamic -module 
  • plugins/kdepim/src/kaddrbook.cpp

    r1675 r1757  
    189189        OSyncChangeType chtype = osync_change_get_changetype(chg); 
    190190        switch(chtype) { 
    191                 case CHANGE_MODIFIED: { 
     191                case OSYNC_CHANGE_TYPE_MODIFIED: { 
    192192                        KABC::Addressee addressee = converter.parseVCard(QString::fromUtf8(data, data_size)); 
    193193 
     
    205205                        break; 
    206206                } 
    207                 case CHANGE_ADDED: { 
     207                case OSYNC_CHANGE_TYPE_ADDED: { 
    208208                        KABC::Addressee addressee = converter.parseVCard(QString::fromUtf8(data, data_size)); 
    209209 
     
    221221                        break; 
    222222                } 
    223                 case CHANGE_DELETED: { 
     223                case OSYNC_CHANGE_TYPE_DELETED: { 
    224224                        if (uid.isEmpty()) { 
    225225                                osync_context_report_error(ctx, OSYNC_ERROR_FILE_NOT_FOUND, "Trying to delete entry with empty UID"); 
  • plugins/kdepim/src/kcal.cpp

    r1675 r1757  
    216216        osync_debug("kcal", 3, "%s", __FUNCTION__); 
    217217        switch (type) { 
    218                 case CHANGE_DELETED: { 
     218                case OSYNC_CHANGE_TYPE_DELETED: { 
    219219                        KCal::Incidence *e = calendar->incidence(osync_change_get_uid(chg)); 
    220220                        if (!e) { 
     
    225225                        break; 
    226226                } 
    227                 case CHANGE_ADDED: 
    228                 case CHANGE_MODIFIED: { 
     227                case OSYNC_CHANGE_TYPE_ADDED: 
     228                case OSYNC_CHANGE_TYPE_MODIFIED: { 
    229229                        KCal::ICalFormat format; 
    230230 
     
    258258                        for (KCal::Incidence::List::ConstIterator i = evts.begin(); i != evts.end(); i++) { 
    259259                                KCal::Incidence *e = (*i)->clone(); 
    260                                 if (type == CHANGE_MODIFIED) 
     260                                if (type == OSYNC_CHANGE_TYPE_MODIFIED) 
    261261                                        e->setUid(osync_change_get_uid(chg)); 
    262262 
  • plugins/kdepim/src/kdepim_impl.cpp

    r1679 r1757  
    6464                            "libopensync-kdepim-plugin",         // internal program name 
    6565                            "OpenSync-KDE-plugin",               // displayable program name. 
    66                             "0.1",                               // version string 
     66                            "0.2",                               // version string 
    6767                            "OpenSync KDEPIM plugin",            // short porgram description 
    6868                            KAboutData::License_GPL,             // license type 
    69                             "(c) 2005, Eduardo Pereira Habkost", // copyright statement 
     69                            "(c) 2005, Eduardo Pereira Habkost, (c)", // copyright statement 
    7070                            0,                                   // any free form text 
    7171                            "http://www.opensync.org",           // program home page address 
     
    9292                        mHashtable = osync_hashtable_new(); 
    9393 
    94                         mKcal = new KCalDataSource(mMember, mHashtable); 
    95                         mKnotes = new KNotesDataSource(mMember, mHashtable); 
    9694                        mKaddrbook = new KContactDataSource(mMember, mHashtable); 
    9795 
     
    102100                virtual ~KdePluginImplementation() 
    103101                { 
    104                         delete mKcal; 
    105                         mKcal = 0; 
    106  
    107                         delete mKnotes; 
    108                         mKnotes = 0; 
    109  
    110102                        if ( mNewApplication ) { 
    111103                                delete mApplication; 
     
    129121                        } 
    130122 
    131  
    132                         if (mKcal && (osync_member_objtype_enabled(mMember, "todo") || 
    133                                       osync_member_objtype_enabled(mMember, "event")) && !mKcal->connect(ctx)) { 
    134                                 osync_trace(TRACE_EXIT_ERROR, "%s: Unable to open calendar", __func__); 
    135                                 return; 
    136                         } 
    137  
    138                         if (mKnotes && osync_member_objtype_enabled(mMember, "note") && \ 
    139                                 !mKnotes->connect(ctx)) { 
    140                                 osync_trace(TRACE_EXIT_ERROR, "%s: Unable to open notes", __func__); 
    141                                 return; 
    142                         } 
    143  
    144123                        if (mKaddrbook && osync_member_objtype_enabled(mMember, "contact") && \ 
    145124                                !mKaddrbook->connect(ctx)) { 
     
    156135                        osync_hashtable_close(mHashtable); 
    157136 
    158                         if (mKcal && mKcal->connected && !mKcal->disconnect(ctx)) 
    159                                 return; 
    160                         if (mKnotes && mKnotes->connected && !mKnotes->disconnect(ctx)) 
    161                                 return; 
    162137                        if (mKaddrbook && mKaddrbook->connected && !mKaddrbook->disconnect(ctx)) 
    163138                                return; 
     
    173148                                osync_anchor_update(mMember, "contact", "true"); 
    174149                        } 
    175  
    176                         if (mKcal && mKcal->connected && 
    177                                  osync_member_objtype_enabled(mMember, "event")) 
    178                         { 
    179                                 osync_anchor_update(mMember, "event", "true"); 
    180                         } 
    181  
    182                         if (mKcal && mKcal->connected && 
    183                                  osync_member_objtype_enabled(mMember, "todo")) 
    184                         { 
    185                                 osync_anchor_update(mMember, "todo", "true"); 
    186                         } 
    187  
    188                         if (mKnotes && mKnotes->connected) 
    189                         { 
    190                                 osync_anchor_update(mMember, "note", "true"); 
    191                         } 
    192  
    193150                        osync_context_report_success(ctx); 
    194151                } 
     
    198155                        if (mKaddrbook && mKaddrbook->connected && !mKaddrbook->contact_get_changeinfo(ctx)) 
    199156                                return; 
    200  
    201                         if (mKcal && mKcal->connected && 
    202                                 osync_member_objtype_enabled(mMember, "event") && 
    203                                  !mKcal->get_changeinfo_events(ctx)) 
    204                                 return; 
    205  
    206                         if (mKcal && mKcal->connected && 
    207                                  osync_member_objtype_enabled(mMember, "todo") && 
    208                                  !mKcal->get_changeinfo_todos(ctx)) 
    209                                 return; 
    210  
    211                         if (mKnotes && mKnotes->connected && !mKnotes->get_changeinfo(ctx)) 
    212                                 return; 
    213  
    214157                        osync_context_report_success(ctx); 
    215158                } 
     
    236179                        return true; 
    237180                } 
    238  
    239                 virtual bool event_access(OSyncContext *ctx, OSyncChange *chg) 
    240                 { 
    241                         if (mKcal) 
    242                                 return mKcal->event_access(ctx, chg); 
    243                         else { 
    244                                 osync_context_report_error(ctx, OSYNC_ERROR_NOT_SUPPORTED, "No calendar loaded"); 
    245                                 return false; 
    246                         } 
    247                         return true; 
    248                 } 
    249  
    250                 virtual bool event_commit_change(OSyncContext *ctx, OSyncChange *chg) 
    251                 { 
    252                         if (mKcal) 
    253                                 return mKcal->event_commit_change(ctx, chg); 
    254                         else { 
    255                                 osync_context_report_error(ctx, OSYNC_ERROR_NOT_SUPPORTED, "No calendar loaded"); 
    256                                 return false; 
    257                         } 
    258                         return true; 
    259                 } 
    260  
    261                 virtual bool todo_access(OSyncContext *ctx, OSyncChange *chg) 
    262                 { 
    263                         if (mKcal) 
    264                                 return mKcal->todo_access(ctx, chg); 
    265                         else { 
    266                                 osync_context_report_error(ctx, OSYNC_ERROR_NOT_SUPPORTED, "No calendar loaded"); 
    267                                 return false; 
    268                         } 
    269                         return true; 
    270                 } 
    271  
    272                 virtual bool todo_commit_change(OSyncContext *ctx, OSyncChange *chg) 
    273                 { 
    274                         if (mKcal) 
    275                                 return mKcal->todo_commit_change(ctx, chg); 
    276                         else { 
    277                                 osync_context_report_error(ctx, OSYNC_ERROR_NOT_SUPPORTED, "No calendar loaded"); 
    278                                 return false; 
    279                         } 
    280                         return true; 
    281                 } 
    282  
    283                 virtual bool note_access(OSyncContext *ctx, OSyncChange *chg) 
    284                 { 
    285                         if (mKnotes) 
    286                                 return mKnotes->access(ctx, chg); 
    287                         else { 
    288                                 osync_context_report_error(ctx, OSYNC_ERROR_NOT_SUPPORTED, "No notes loaded"); 
    289                                 return false; 
    290                         } 
    291                         return true; 
    292                 } 
    293  
    294                 virtual bool note_commit_change(OSyncContext *ctx, OSyncChange *chg) 
    295                 { 
    296                         if (mKnotes) 
    297                                 return mKnotes->commit_change(ctx, chg); 
    298                         else { 
    299                                 osync_context_report_error(ctx, OSYNC_ERROR_NOT_SUPPORTED, "No notes loaded"); 
    300                                 return false; 
    301                         } 
    302                         return true; 
    303                 } 
    304  
    305181        private: 
    306                 KCalDataSource *mKcal; 
    307                 KNotesDataSource *mKnotes; 
    308182                KContactDataSource *mKaddrbook; 
    309183 
     
    319193{ 
    320194 
    321         KdePluginImplementationBase *new_KdePluginImplementation(OSyncMember *member, OSyncError **error) { 
    322                 KdePluginImplementation *imp = new KdePluginImplementation(member); 
     195        KdePluginImplementationBase *new_KdePluginImplementation(OSyncPlugin *plugin, OSyncPluginInfo *info, OSyncError **error) { 
     196                KdePluginImplementation *imp = new KdePluginImplementation(plugin, info, error); 
    323197                if (!imp->init(error)) { 
    324198                        delete imp; 
  • plugins/kdepim/src/kdepim_sync.cpp

    r1675 r1757  
    2222/** 
    2323 * @autor Eduardo Pereira Habkost <ehabkost@conectiva.com.br> 
     24 * edit Matthias Jahn <jahn.matthias@freenet.de> 
    2425 */ 
    2526 
     
    4142 * @see KdePluginImplementationBase 
    4243 */ 
    43 static void *kde_initialize(OSyncMember *member, OSyncError **e) 
     44static void *kde_initialize(OSyncPlugin *plugin, OSyncPluginInfo *info, OSyncError **error) 
    4445{ 
    4546        KdeImplInitFunc init_func; 
     
    130131} 
    131132 
    132 static osync_bool kde_event_commit_change(OSyncContext *ctx, OSyncChange *change) 
    133 { 
    134         KdePluginImplementationBase *impl_object = impl_object_for_context(ctx); 
    135  
    136         osync_debug("kde", 3, "%s()",__FUNCTION__); 
    137  
    138         return impl_object->event_commit_change(ctx, change); 
    139 } 
    140  
    141 static osync_bool kde_event_access(OSyncContext *ctx, OSyncChange *change) 
    142 { 
    143         KdePluginImplementationBase *impl_object = impl_object_for_context(ctx); 
    144  
    145         osync_debug("kde", 3, "%s()",__FUNCTION__); 
    146  
    147         return impl_object->event_access(ctx, change); 
    148 } 
    149  
    150 static osync_bool kde_todo_commit_change(OSyncContext *ctx, OSyncChange *change) 
    151 { 
    152         KdePluginImplementationBase *impl_object = impl_object_for_context(ctx); 
    153  
    154         osync_debug("kde", 3, "%s()",__FUNCTION__); 
    155  
    156         return impl_object->todo_commit_change(ctx, change); 
    157 } 
    158  
    159 static osync_bool kde_todo_access(OSyncContext *ctx, OSyncChange *change) 
    160 { 
    161         KdePluginImplementationBase *impl_object = impl_object_for_context(ctx); 
    162  
    163         osync_debug("kde", 3, "%s()",__FUNCTION__); 
    164  
    165         return impl_object->todo_access(ctx, change); 
    166 } 
    167  
    168 static osync_bool kde_note_commit_change(OSyncContext *ctx, OSyncChange *change) 
    169 { 
    170         KdePluginImplementationBase *impl_object = impl_object_for_context(ctx); 
    171  
    172         osync_debug("kde", 3, "%s()",__FUNCTION__); 
    173  
    174         return impl_object->note_commit_change(ctx, change); 
    175 } 
    176  
    177 static osync_bool kde_note_access(OSyncContext *ctx, OSyncChange *change) 
    178 { 
    179         KdePluginImplementationBase *impl_object = impl_object_for_context(ctx); 
    180  
    181         osync_debug("kde", 3, "%s()",__FUNCTION__); 
    182  
    183         return impl_object->note_access(ctx, change); 
    184 } 
    185  
    186133extern "C" 
    187134{ 
    188         void get_info(OSyncEnv *env) { 
    189                 OSyncPluginInfo *info = osync_plugin_new_info(env); 
    190                 info->version = 1; 
    191                 info->name = "kdepim-sync"; 
    192                 /*FIXME: i18n */ 
    193                 info->longname = "KDE Desktop"; 
    194                 info->description = "Plugin for the KDE 3.5 Desktop"; 
    195                 info->config_type = NO_CONFIGURATION; 
    196  
    197                 info->functions.initialize = kde_initialize; 
    198                 info->functions.connect = kde_connect; 
    199                 info->functions.disconnect = kde_disconnect; 
    200                 info->functions.finalize = kde_finalize; 
    201                 info->functions.get_changeinfo = kde_get_changeinfo; 
    202                 info->functions.sync_done = kde_sync_done; 
    203  
    204                 osync_plugin_accept_objtype(info, "contact"); 
    205                 osync_plugin_accept_objformat(info, "contact", "vcard30", "kde"); 
    206                 osync_plugin_set_commit_objformat(info, "contact", "vcard30", kde_vcard_commit_change); 
    207                 osync_plugin_set_access_objformat(info, "contact", "vcard30", kde_vcard_access); 
    208                 osync_plugin_accept_objformat(info, "contact", "vcard21", "kde"); 
    209                 osync_plugin_set_commit_objformat(info, "contact", "vcard21", kde_vcard_commit_change); 
    210                 osync_plugin_set_access_objformat(info, "contact", "vcard21", kde_vcard_access); 
    211  
    212                 osync_plugin_accept_objtype(info, "event"); 
    213                 osync_plugin_accept_objformat(info, "event", "vevent20", "kde"); 
    214                 osync_plugin_set_commit_objformat(info, "event", "vevent20", kde_event_commit_change); 
    215                 osync_plugin_set_access_objformat(info, "event", "vevent20", kde_event_access); 
    216  
    217                 osync_plugin_accept_objtype(info, "todo"); 
    218                 osync_plugin_accept_objformat(info, "todo", "vtodo20", "kde"); 
    219                 osync_plugin_set_commit_objformat(info, "todo", "vtodo20", kde_todo_commit_change); 
    220                 osync_plugin_set_access_objformat(info, "todo", "vtodo20", kde_todo_access); 
    221  
    222                 osync_plugin_accept_objtype(info, "note"); 
    223                 osync_plugin_accept_objformat(info, "note", "xml-note", NULL); 
    224                 osync_plugin_set_commit_objformat(info, "note", "xml-note", kde_note_commit_change); 
    225                 osync_plugin_set_access_objformat(info, "note", "xml-note", kde_note_access); 
    226         } 
     135 
     136/* Here we actually tell opensync which sinks are available. For this plugin, we 
     137 * go through the list of directories and enable all, since all have been configured */ 
     138static osync_bool kde_discover(void *data, OSyncPluginInfo *info, OSyncError **error) 
     139{ 
     140        osync_trace(TRACE_ENTRY, "%s(%p, %p, %p)", __func__, data, info, error); 
     141         
     142        OSyncEvoEnv *env = (OSyncEvoEnv *)data; 
     143 
     144        osync_objtype_sink_set_available(env->contact_sink, TRUE); 
     145 
     146        osync_trace(TRACE_EXIT, "%s", __func__); 
     147        return TRUE; 
     148} 
     149 
     150osync_bool get_sync_info(OSyncEnv *env, OSyncError **error) { 
     151 
     152        //OSyncPluginInfo *info = osync_plugin_new_info(env); 
     153        OSyncPlugin *plugin = osync_plugin_new(error); 
     154        if (!plugin) 
     155                goto error; 
     156 
     157        //info->version = 1; 
     158        //now in int get_version(void); 
     159 
     160        //info->name = "kdepim-sync"; 
     161        osync_plugin_set_name(plugin, "kdepim-sync"); 
     162        //info->longname = "KDE Desktop"; 
     163        osync_plugin_set_longname(plugin, "KDE Desktop"); 
     164        //info->description = "Plugin for the KDE 3.5 Desktop"; 
     165        osync_plugin_set_description(plugin, "Plugin for the KDE 3.5 Desktop"); 
     166 
     167        //info->config_type = NO_CONFIGURATION; 
     168        osync_plugin_set_config_type(plugin, OSYNC_PLUGIN_NO_CONFIGURATION); 
     169 
     170        //info->functions.initialize = kde_initialize; 
     171        osync_plugin_set_initialize(plugin, kde_initialize); 
     172         
     173        //info->functions.connect = kde_connect; 
     174        //now in initialize 
     175        //info->functions.disconnect = kde_disconnect; 
     176        //now in finalize 
     177 
     178        //info->functions.finalize = kde_finalize; 
     179        osync_plugin_set_finalize(plugin, kde_finalize); 
     180        osync_plugin_set_discover(plugin, kde_discover); 
     181         
     182        info->functions.get_changeinfo = kde_get_changeinfo; 
     183        info->functions.sync_done = kde_sync_done; 
     184 
     185        osync_plugin_env_register_plugin(env, plugin); 
     186        osync_plugin_unref(plugin); 
     187        return TRUE; 
     188 
     189error: 
     190        osync_trace(TRACE_ERROR, "Unable to register: %s", osync_error_print(error)); 
     191        osync_error_unref(error); 
     192        return FALSE; 
     193} 
     194 
     195int get_version(void) 
     196{ 
     197        return 1; 
     198} 
    227199 
    228200}// extern "C" 
  • plugins/kdepim/src/knotes.cpp

    r1676 r1757  
    243243        KMD5 hash_value; 
    244244 
    245         if (type != CHANGE_DELETED) { 
     245        if (type != OSYNC_CHANGE_TYPE_DELETED) { 
    246246 
    247247                // Get osxml data 
     
    278278                QString hash; 
    279279                switch (type) { 
    280                         case CHANGE_ADDED: { 
     280                        case OSYNC_CHANGE_TYPE_ADDED: { 
    281281                                osync_trace(TRACE_INTERNAL, "addding new \"%s\" and \"%s\"\n", (const char*)summary.local8Bit(), (const char*)body.local8Bit()); 
    282282                                uid = kn_iface->newNote(summary, body); 
     
    297297                                break; 
    298298                        } 
    299                         case CHANGE_MODIFIED: { 
     299                        case OSYNC_CHANGE_TYPE_MODIFIED: { 
    300300                                kn_iface->setName(uid, summary); 
    301301                                if (kn_iface->status() != DCOPStub::CallSucceeded) { 
  • plugins/kdepim/src/osyncbase.h

    r1675 r1757  
    2525                virtual bool vcard_commit_change(OSyncContext *ctx, OSyncChange *chg) = 0; 
    2626 
    27                 virtual bool event_access(OSyncContext *ctx, OSyncChange *chg) = 0; 
    28                 virtual bool event_commit_change(OSyncContext *ctx, OSyncChange *chg) = 0; 
    29  
    30                 virtual bool todo_access(OSyncContext *ctx, OSyncChange *chg) = 0; 
    31                 virtual bool todo_commit_change(OSyncContext *ctx, OSyncChange *chg) = 0; 
    32  
    33                 virtual bool note_access(OSyncContext *ctx, OSyncChange *chg) = 0; 
    34                 virtual bool note_commit_change(OSyncContext *ctx, OSyncChange *chg) = 0; 
    3527 
    3628                /* The declaration above seemed to be necessary just because the