Changeset 2451

Show
Ignore:
Timestamp:
08/15/07 15:14:04 (1 year ago)
Author:
paule
Message:

Add alarm support for todos/events - still needs testing

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • plugins/opie-sync/src/opie_format.c

    r2448 r2451  
    674674                /* Due date */ 
    675675                GDate *duedate = NULL; 
     676                char *duedatestr = NULL; 
    676677                char *hasDate = xmlGetProp(icur, "HasDate"); 
    677678                if(hasDate) {  
     
    684685                                        int datemonth = atoi(datemonthstr); 
    685686                                        int dateday = atoi(datedaystr); 
    686                                         char *duedatestr = g_strdup_printf("%04d%02d%02d", dateyear, datemonth, dateday); 
     687                                        duedatestr = g_strdup_printf("%04d%02d%02d", dateyear, datemonth, dateday); 
    687688                                        duedate = g_date_new_dmy(dateday, datemonth, dateyear); 
    688689                                        out_xmlfield = osync_xmlfield_new(out_xmlformat, "DateDue", error); 
    689690                                        osync_xmlfield_set_key_value(out_xmlfield, "Content", duedatestr); 
    690                                         g_free(duedatestr); 
    691691                                        // RFC2445 says the default value type is DATE-TIME. But Opie only 
    692692                                        // stores DATE as due date => alter VALUE to DATE 
     
    705705                /* Alarms */ 
    706706                char *alarmstr = xmlGetProp(icur, "Alarms"); 
    707                 if(alarmstr) { 
    708                         xml_todo_alarm_attr_to_xmlfield(alarmstr, out_xmlformat, NULL, error); 
     707                if(alarmstr && duedatestr) { 
     708                        char *duetimestr = g_strdup_printf("%sT000000", duedatestr); 
     709                        time_t duetime = osync_time_vtime2unix(duetimestr, 0); 
     710                        xml_todo_alarm_attr_to_xmlfield(alarmstr, out_xmlformat, &duetime, error); 
     711                        g_free(duetimestr); 
     712                } 
     713                if(duedatestr) 
     714                        g_free(duedatestr); 
     715                if(alarmstr) 
    709716                        xmlFree(alarmstr); 
    710                 } 
    711717                 
    712718                if(duedate) 
     
    870876         
    871877        /* Convert alarms */ 
    872         xmlformat_todo_alarms_to_attr(in_xmlformat, on_todo); 
     878        xmlformat_todo_alarms_to_attr(in_xmlformat, on_todo, duestr); 
    873879         
    874880        if(!completedstr) 
     
    17091715                int i,j; 
    17101716                for(j=0; alarmentries[j] != NULL; j++) { 
    1711 //                    OSyncXMLField *out_xmlfield = osync_xmlfield_new(out_xmlformat, "Alarm", error); 
     1717                      OSyncXMLField *out_xmlfield = osync_xmlfield_new(out_xmlformat, "Alarm", error); 
    17121718                         
    17131719                        // Opie alarm entry format: ddmmyyyyhhmmss:0:<0=silent,1=loud>:[;nextalarmentry] 
     
    17261732                        g_strfreev(alarmargs); 
    17271733                         
    1728                         /* FIXME since alarm support is not complete in the OpenSync xmlformat code, the code  
    1729                            below is not finished */ 
    1730                          
    1731 /*  
    17321734                        if(alarmsound == 1) 
    17331735                                osync_xmlfield_set_key_value(out_xmlfield, "AlarmAction", "AUDIO"); 
     
    17421744                                 
    17431745                                if(starttime) { 
    1744                                         // This is nice in theory, but Opie todo events don't support due time so 
    1745                                         //  we can't use this code in practice 
    17461746                                        char *alarmdu = osync_time_sec2alarmdu((int)difftime(alarmtime, *starttime));  
    17471747                                        if(alarmdu) { 
    1748                                                 xmlNode *on_trigger = xmlNewTextChild(node_to, NULL, (xmlChar*) "AlarmTrigger", NULL); 
    1749                                                 xmlNewTextChild(on_trigger, NULL, (xmlChar*)"Content", (xmlChar*) alarmdu); 
    1750                                                 xmlNewTextChild(on_trigger, NULL, (xmlChar*)"Value", (xmlChar*) "DURATION"); 
     1748                                                osync_xmlfield_set_key_value(out_xmlfield, "AlarmTrigger", alarmdu); 
     1749                                                g_free(alarmdu); 
    17511750                                        } 
    1752                                 } 
    1753                                 else { 
    1754                                         xmlNode *on_trigger = xmlNewTextChild(node_to, NULL, (xmlChar*) "AlarmTrigger", NULL); 
    1755                                         xmlNewTextChild(on_trigger, NULL, (xmlChar*)"Content", (xmlChar*) alarmdatestr_utc); 
    1756                                         xmlNewTextChild(on_trigger, NULL, (xmlChar*)"Value", (xmlChar*) "DATE-TIME"); 
    17571751                                } 
    17581752                                g_free(alarmdatestr_utc); 
     
    17601754                                g_free(alarmdatestr); 
    17611755                        } 
    1762 */ 
    17631756                } 
    17641757                g_strfreev(alarmentries); 
     
    17661759} 
    17671760 
    1768 void xmlformat_todo_alarms_to_attr(OSyncXMLFormat *in_xmlformat, xmlNode *node_to) { 
     1761void xmlformat_todo_alarms_to_attr(OSyncXMLFormat *in_xmlformat, xmlNode *node_to, const char *duedate) { 
    17691762        /* Convert OpenSync XML Alarm entries on a todo node to Opie Alarms attribute value */ 
    1770 /*      xmlNode *cur; 
    1771         xmlNode *alarm_node; 
    1772         int i, numnodes;*/ 
    17731763         
    17741764        GString *alarms = g_string_new(""); 
     
    17781768                const char *fieldname = osync_xmlfield_get_name(in_xmlfield); 
    17791769                if(!strcmp("Alarm", fieldname)) { 
    1780                         /* FIXME since alarm support is not complete in the OpenSync xmlformat code, the code  
    1781                            below is not finished */ 
    1782 /*  
    17831770                        char *alarmdatestr = NULL; 
    1784                         xmlNode *trigger_node = osxml_get_node(alarm_node, "AlarmTrigger"); 
    1785                         if(trigger_node) { 
    1786                                 char *typestr = NULL; 
    1787                                 char *contentstr = NULL; 
    1788                                 cur = osxml_get_node(trigger_node, "Value"); 
    1789                                 if(cur) 
    1790                                         typestr = xmlNodeGetContent(cur); 
    1791                                 cur = osxml_get_node(trigger_node, "Content"); 
    1792                                 if(cur) 
    1793                                         contentstr = xmlNodeGetContent(cur); 
     1771                        const char *trigger = osync_xmlfield_get_key_value(in_xmlfield, "AlarmTrigger"); 
     1772                        if(trigger) { 
     1773                                struct tm *alarmtm = NULL; 
     1774                                time_t alarmtime = 0; 
     1775                                         
     1776                                if(duedate) { 
     1777                                        int alarmdiff = osync_time_alarmdu2sec(trigger); 
     1778                                        alarmtm = osync_time_vtime2tm(duedate); 
     1779                                        alarmtime = timegm(alarmtm); 
     1780                                        alarmtime += alarmdiff; 
     1781                                } 
    17941782                                 
    1795                                 if(contentstr && typestr) { 
    1796                                         struct tm *alarmtm = NULL; 
    1797                                         time_t alarmtime = 0; 
    1798                                         if(!strcmp(typestr, "DATE-TIME")) { 
    1799                                                 alarmtm = osync_time_vtime2tm(contentstr); 
    1800                                                 alarmtime = timegm(alarmtm); 
    1801                                         } 
    1802                                         else if (!strcmp(typestr, "DURATION")) { 
    1803                                                 cur = osxml_get_node(item_node, "DateDue"); 
    1804                                                 if(cur) { 
    1805                                                         cur = osxml_get_node(cur, "Content"); 
    1806                                                         if(cur) { 
    1807                                                                 char *duedatestr = xmlNodeGetContent(cur); 
    1808                                                                 if(duedatestr) { 
    1809                                                                         int alarmdiff = osync_time_alarmdu2sec(contentstr); 
    1810                                                                         alarmtm = osync_time_vtime2tm(duedatestr); 
    1811                                                                         alarmtime = timegm(alarmtm); 
    1812                                                                         alarmtime += alarmdiff; 
    1813                                                                         xmlFree(duedatestr); 
    1814                                                                 } 
    1815                                                         } 
    1816                                                 } 
    1817                                         } 
    1818                                          
    1819                                         if(alarmtm) { 
    1820                                                 struct tm *alarmtm_local = g_malloc0(sizeof(struct tm)); 
    1821                                                 localtime_r(&alarmtime, alarmtm_local); 
    1822                                                 alarmdatestr = g_strdup_printf("%02d%02d%04d%02d%02d%02d",  
    1823                                                                                                                                                                         alarmtm_local->tm_mday, alarmtm_local->tm_mon + 1, alarmtm_local->tm_year + 1900,  
    1824                                                                                                                                                                         alarmtm_local->tm_hour, alarmtm_local->tm_min, alarmtm_local->tm_sec); 
    1825                                                 g_free(alarmtm_local); 
    1826                                                 g_free(alarmtm); 
    1827                                         } 
    1828                                 } 
    1829                                  
    1830                                 if(contentstr) 
    1831                                         xmlFree(contentstr); 
    1832                                 if(typestr) 
    1833                                         xmlFree(typestr); 
     1783                                if(alarmtm) { 
     1784                                        struct tm *alarmtm_local = g_malloc0(sizeof(struct tm)); 
     1785                                        localtime_r(&alarmtime, alarmtm_local); 
     1786                                        alarmdatestr = g_strdup_printf("%02d%02d%04d%02d%02d%02d",  
     1787                                                                                                                                                                alarmtm_local->tm_mday, alarmtm_local->tm_mon + 1, alarmtm_local->tm_year + 1900,  
     1788                                                                                                                                                                alarmtm_local->tm_hour, alarmtm_local->tm_min, alarmtm_local->tm_sec); 
     1789                                        g_free(alarmtm_local); 
     1790                                        g_free(alarmtm); 
     1791                                } 
    18341792                        } 
    18351793                         
    18361794                        if(alarmdatestr) { 
    1837                                 cur = osxml_get_node(alarm_node, "AlarmAction"); 
    18381795                                int alarmsound = 0; 
    1839                                 if(cur) { 
    1840                                         char *alarmaction = xmlNodeGetContent(cur); 
    1841                                         if(alarmaction) { 
    1842                                                 if(!strcmp(alarmaction, "AUDIO")) 
    1843                                                         alarmsound = 1; 
    1844                                                 xmlFree(alarmaction); 
    1845                                         } 
     1796                                const char *alarmaction = osync_xmlfield_get_key_value(in_xmlfield, "AlarmAction"); 
     1797                                if(alarmaction) { 
     1798                                        if(!strcmp(alarmaction, "AUDIO")) 
     1799                                                alarmsound = 1; 
    18461800                                } 
    18471801                                g_string_append_printf(alarms, "%s:0:%d:;", alarmdatestr, alarmsound); 
    18481802                        } 
    1849 */               
    18501803                         
    18511804                } 
     
    18631816        /* Convert OpenSync XML Alarm entries on a calendar event node to Opie alarm/sound attribute values */ 
    18641817         
    1865 /*       
    1866         xmlNode *cur; 
    18671818        int alarmseconds = 15 * 60; // Default 15 minutes 
    18681819                 
    1869         xmlNode *alarm_node = osxml_get_node(item_node, "Alarm"); 
    1870         if(alarm_node) { 
    1871                 xmlNode *trigger_node = osxml_get_node(alarm_node, "AlarmTrigger"); 
    1872                 if(trigger_node) { 
    1873                         char *typestr = NULL; 
    1874                         char *contentstr = NULL; 
    1875                         cur = osxml_get_node(trigger_node, "Value"); 
    1876                         if(cur) 
    1877                                 typestr = xmlNodeGetContent(cur); 
    1878                         cur = osxml_get_node(trigger_node, "Content"); 
    1879                         if(cur) 
    1880                                 contentstr = xmlNodeGetContent(cur); 
     1820        OSyncXMLField *in_xmlfield = osync_xmlformat_get_first_field(in_xmlformat); 
     1821        while(in_xmlfield) { 
     1822                const char *fieldname = osync_xmlfield_get_name(in_xmlfield); 
     1823                if(!strcmp("Alarm", fieldname)) { 
     1824                        const char *trigger = osync_xmlfield_get_key_value(in_xmlfield, "AlarmTrigger"); 
     1825                        if(trigger) 
     1826                                alarmseconds = osync_time_alarmdu2sec(trigger); 
    18811827                         
    1882                         if(contentstr && typestr) { 
    1883                                 if(!strcmp(typestr, "DATE-TIME")) { 
    1884                                         if(starttime) { 
    1885                                                 struct tm *alarmtm = osync_time_vtime2tm(contentstr); 
    1886                                                 time_t alarmtime = timegm(alarmtm); 
    1887                                                 alarmseconds = (int)difftime(alarmtime, *starttime); 
    1888                                                 g_free(alarmtm); 
    1889                                         } 
    1890                                 } 
    1891                                 else if (!strcmp(typestr, "DURATION")) { 
    1892                                         alarmseconds = osync_time_alarmdu2sec(contentstr); 
    1893                                 } 
     1828                        const char *alarmaction = osync_xmlfield_get_key_value(in_xmlfield, "AlarmAction"); 
     1829                        int alarmsound = 0; 
     1830                        if(alarmaction) { 
     1831                                if(!strcmp(alarmaction, "AUDIO")) 
     1832                                        alarmsound = 1; 
    18941833                        } 
    18951834                         
    1896                         if(contentstr) 
    1897                                 xmlFree(contentstr); 
    1898                         if(typestr) 
    1899                                 xmlFree(typestr); 
    1900                  
    19011835                        char *alarmstr = g_strdup_printf("%d", alarmseconds / 60); 
    19021836                        xmlSetProp(node_to, "alarm", alarmstr); 
    19031837                        g_free(alarmstr); 
    1904                          
    1905                         cur = osxml_get_node(alarm_node, "AlarmAction"); 
    1906                         int alarmsound = 0; 
    1907                         if(cur) { 
    1908                                 char *alarmaction = xmlNodeGetContent(cur); 
    1909                                 if(alarmaction) { 
    1910                                         if(!strcmp(alarmaction, "AUDIO")) 
    1911                                                 alarmsound = 1; 
    1912                                         xmlFree(alarmaction); 
    1913                                 } 
    1914                         } 
    19151838                         
    19161839                        if(alarmsound == 1) 
     
    19181841                        else 
    19191842                                xmlSetProp(node_to, "sound", "silent"); 
    1920                 } 
    1921         } 
    1922 */ 
     1843                         
     1844                        /* Opie calendar only supports one alarm, so take the first one */ 
     1845                        break; 
     1846                } 
     1847                 
     1848                in_xmlfield = osync_xmlfield_get_next(in_xmlfield); 
     1849        } 
    19231850} 
  • plugins/opie-sync/src/opie_format.h

    r2442 r2451  
    3434void xmlfield_recur_to_attr(OSyncXMLField *in_xmlfield, xmlNode *node_to); 
    3535void xml_todo_alarm_attr_to_xmlfield(const char *alarmstr, OSyncXMLFormat *out_xmlformat, time_t *starttime, OSyncError **error); 
    36 void xmlformat_todo_alarms_to_attr(OSyncXMLFormat *in_xmlformat, xmlNode *node_to); 
     36void xmlformat_todo_alarms_to_attr(OSyncXMLFormat *in_xmlformat, xmlNode *node_to, const char *duedate); 
    3737void xmlformat_cal_alarms_to_attr(OSyncXMLFormat *in_xmlformat, xmlNode *node_to, time_t *starttime); 
    3838