← Back to branch summary

~ubuntu-branches/ubuntu/trusty/modem-manager-gui/trusty-backports

« back to all changes in this revision

Viewing changes to src/strformat.c

  • Committer: Package Import Robot
  • Author(s): Graham Inggs
  • Date: 2013-07-30 12:51:59 UTC
  • Revision ID: package-import@ubuntu.com-20130730125159-flzv882fhuzhmfmi
Tags: upstream-0.0.16
Import upstream version 0.0.16

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/strformat.c
 
1
/*
 
2
 *      strformat.c
 
3
 *      
 
4
 *      Copyright 2013 Alex <alex@linuxonly.ru>
 
5
 *      
 
6
 *      This program is free software: you can redistribute it and/or modify
 
7
 *      it under the terms of the GNU General Public License as published by
 
8
 *      the Free Software Foundation; either version 3 of the License, or
 
9
 *      (at your option) any later version.
 
10
 *      
 
11
 *      This program is distributed in the hope that it will be useful,
 
12
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 *      GNU General Public License for more details.
 
15
 *      
 
16
 *      You should have received a copy of the GNU General Public License
 
17
 *      along with this program. If not, see <http://www.gnu.org/licenses/>.
 
18
 */
 
19
 
 
20
#include <stdlib.h>
 
21
#include <stdio.h>
 
22
#include <string.h>
 
23
#include <glib.h>
 
24
#include <glib/gi18n.h>
 
25
 
 
26
#include "strformat.h"
 
27
#include "mmguicore.h"
 
28
 
 
29
gchar *mmgui_str_format_speed(gfloat speed, gchar *buffer, gsize bufsize, gboolean small)
 
30
{
 
31
        gdouble fpvalue;
 
32
        
 
33
        if ((buffer == NULL) || (bufsize == 0)) return NULL;
 
34
        
 
35
        memset(buffer, 0, bufsize);
 
36
        
 
37
        if (speed < 1024.0) {
 
38
                if (small) {
 
39
                        g_snprintf(buffer, bufsize, _("<small><b>%.3f kbps</b></small>"), speed);
 
40
                } else {
 
41
                        g_snprintf(buffer, bufsize, _("%.3f kbps"), speed);
 
42
                }
 
43
        } else if ((speed >= 1024.0) && (speed < 1048576.0)) {
 
44
                fpvalue = speed / (gdouble)(1024.0);
 
45
                if (small) {
 
46
                        g_snprintf(buffer, bufsize, _("<small><b>%.3g Mbps</b></small>"), fpvalue);
 
47
                } else {
 
48
                        g_snprintf(buffer, bufsize, _("%.3g Mbps"), fpvalue);
 
49
                }
 
50
        } else {
 
51
                fpvalue = speed / (gdouble)(1048576.0);
 
52
                if (small) {
 
53
                        g_snprintf(buffer, bufsize, _("<small><b>%.3g Gbps</b></small>"), fpvalue);
 
54
                } else {
 
55
                        g_snprintf(buffer, bufsize, _("%.3g Gbps"), fpvalue);
 
56
                }
 
57
        }
 
58
        
 
59
        return buffer;  
 
60
}
 
61
 
 
62
gchar *mmgui_str_format_time_number(guchar number, gchar *buffer, gsize bufsize)
 
63
{
 
64
        if ((buffer == NULL) || (bufsize == 0)) return NULL;
 
65
        
 
66
        memset(buffer, 0, bufsize);
 
67
        
 
68
        if (number < 10) {
 
69
                g_snprintf(buffer, bufsize, "0%u", (guint)number);
 
70
        } else {
 
71
                g_snprintf(buffer, bufsize, "%u", (guint)number);
 
72
        }
 
73
        
 
74
        return buffer;
 
75
}
 
76
 
 
77
gchar *mmgui_str_format_time(guint64 seconds, gchar *buffer, gsize bufsize, gboolean small)
 
78
{
 
79
        gchar secbuffer[3], minbuffer[3], hourbuffer[3];
 
80
        
 
81
        if ((buffer == NULL) || (bufsize == 0)) return NULL;
 
82
        
 
83
        memset(buffer, 0, bufsize);
 
84
        
 
85
        if (seconds < 60) {
 
86
                if (small) {
 
87
                        g_snprintf(buffer, bufsize, _("<small><b>%u sec</b></small>"), (guint)seconds);
 
88
                } else {
 
89
                        g_snprintf(buffer, bufsize, _("%u sec"), (guint)seconds);
 
90
                }
 
91
        } else if ((seconds >= 60) && (seconds < 3600)) {
 
92
                if (small) {
 
93
                        g_snprintf(buffer, bufsize, _("<small><b>%s:%s</b></small>"), mmgui_str_format_time_number(seconds%3600/60, minbuffer, sizeof(minbuffer)), mmgui_str_format_time_number(seconds%60, secbuffer, sizeof(secbuffer)));
 
94
                } else {
 
95
                        g_snprintf(buffer, bufsize, _("%s:%s"), mmgui_str_format_time_number(seconds%3600/60, minbuffer, sizeof(minbuffer)), mmgui_str_format_time_number(seconds%60, secbuffer, sizeof(secbuffer)));
 
96
                }
 
97
        } else if ((seconds >= 3600) && (seconds < 86400)) {
 
98
                if (small) {
 
99
                        g_snprintf(buffer, bufsize, _("<small><b>%s:%s:%s</b></small>"), mmgui_str_format_time_number(seconds%86400/3600, hourbuffer, sizeof(hourbuffer)), mmgui_str_format_time_number(seconds%3600/60, minbuffer, sizeof(minbuffer)), mmgui_str_format_time_number(seconds%60, secbuffer, sizeof(secbuffer)));
 
100
                } else {
 
101
                        g_snprintf(buffer, bufsize, _("%s:%s:%s"), mmgui_str_format_time_number(seconds%86400/3600, hourbuffer, sizeof(hourbuffer)), mmgui_str_format_time_number(seconds%3600/60, minbuffer, sizeof(minbuffer)), mmgui_str_format_time_number(seconds%60, secbuffer, sizeof(secbuffer)));
 
102
                }
 
103
        } else {
 
104
                if (small) {
 
105
                        g_snprintf(buffer, bufsize, _("<small><b>%" G_GUINT64_FORMAT " day(s) %s:%s:%s</b></small>"), seconds/86400, mmgui_str_format_time_number(seconds%86400/3600, hourbuffer, sizeof(hourbuffer)), mmgui_str_format_time_number(seconds%3600/60, minbuffer, sizeof(minbuffer)), mmgui_str_format_time_number(seconds%60, secbuffer, sizeof(secbuffer)));
 
106
                } else {
 
107
                        g_snprintf(buffer, bufsize, _("%" G_GUINT64_FORMAT " day(s) %s:%s:%s"), seconds/86400, mmgui_str_format_time_number(seconds%86400/3600, hourbuffer, sizeof(hourbuffer)), mmgui_str_format_time_number(seconds%3600/60, minbuffer, sizeof(minbuffer)), mmgui_str_format_time_number(seconds%60, secbuffer, sizeof(secbuffer)));
 
108
                }
 
109
        }
 
110
        
 
111
        return buffer;
 
112
}
 
113
 
 
114
gchar *mmgui_str_format_bytes(guint64 bytes, gchar *buffer, gsize bufsize, gboolean small)
 
115
{
 
116
        gdouble fpvalue;
 
117
        
 
118
        if ((buffer == NULL) || (bufsize == 0)) return NULL;
 
119
        
 
120
        memset(buffer, 0, bufsize);
 
121
        
 
122
        if (bytes < 1024) {
 
123
                if (small) {
 
124
                        g_snprintf(buffer, bufsize, _("<small><b>%u</b></small>"), (guint)bytes);
 
125
                } else {
 
126
                        g_snprintf(buffer, bufsize, _("%u"), (guint)bytes);
 
127
                }
 
128
        } else if ((bytes >= 1024) && (bytes < 1048576ull)) {
 
129
                fpvalue = bytes / (gdouble)(1024.0);
 
130
                if (small) {
 
131
                        g_snprintf(buffer, bufsize, _("<small><b>%.3g Kb</b></small>"), fpvalue);
 
132
                } else {
 
133
                        g_snprintf(buffer, bufsize, _("%.3g Kb"), fpvalue);
 
134
                }
 
135
        } else if ((bytes >= 1048576ull) && (bytes < 1073741824ull)) {
 
136
                fpvalue = bytes / (gdouble)(1048576.0);
 
137
                if (small) {
 
138
                        g_snprintf(buffer, bufsize, _("<small><b>%.3g Mb</b></small>"), fpvalue);
 
139
                } else {
 
140
                        g_snprintf(buffer, bufsize, _("%.3g Mb"), fpvalue);
 
141
                }
 
142
        } else if ((bytes >= 1073741824ull) && (bytes < 109951162800ull)) {
 
143
                fpvalue = bytes / (gdouble)(1073741824.0);
 
144
                if (small) {
 
145
                        g_snprintf(buffer, bufsize, _("<small><b>%.3g Gb</b></small>"), fpvalue);
 
146
                } else {
 
147
                        g_snprintf(buffer, bufsize, _("%.3g Gb"), fpvalue);
 
148
                }
 
149
        } else {
 
150
                fpvalue = bytes / (gdouble)(109951162800.0);
 
151
                if (small) {
 
152
                        g_snprintf(buffer, bufsize, _("<small><b>%.3g Tb</b></small>"), fpvalue);
 
153
                } else {
 
154
                        g_snprintf(buffer, bufsize, _("%.3g Tb"), fpvalue);
 
155
                }
 
156
        }
 
157
        
 
158
        return buffer;  
 
159
}
 
160
 
 
161
gchar *mmgui_str_format_mode_string(enum _mmgui_device_modes mode)
 
162
{
 
163
        switch (mode) {
 
164
                case MMGUI_DEVICE_MODE_UNKNOWN:
 
165
                        return _("Unknown");
 
166
                case MMGUI_DEVICE_MODE_GSM:
 
167
                        return "GSM";
 
168
                case MMGUI_DEVICE_MODE_GSM_COMPACT:
 
169
                        return "Compact GSM";
 
170
                case MMGUI_DEVICE_MODE_GPRS:
 
171
                        return "GPRS";
 
172
                case MMGUI_DEVICE_MODE_EDGE:
 
173
                        return "EDGE (ETSI 27.007: \"GSM w/EGPRS\")";
 
174
                case MMGUI_DEVICE_MODE_UMTS:
 
175
                        return "UMTS (ETSI 27.007: \"UTRAN\")";
 
176
                case MMGUI_DEVICE_MODE_HSDPA:
 
177
                        return "HSDPA (ETSI 27.007: \"UTRAN w/HSDPA\")";
 
178
                case MMGUI_DEVICE_MODE_HSUPA:
 
179
                        return "HSUPA (ETSI 27.007: \"UTRAN w/HSUPA\")";
 
180
                case MMGUI_DEVICE_MODE_HSPA:
 
181
                        return "HSPA (ETSI 27.007: \"UTRAN w/HSDPA and HSUPA\")";
 
182
                case MMGUI_DEVICE_MODE_HSPA_PLUS:
 
183
                        return "HSPA+ (ETSI 27.007: \"UTRAN w/HSPA+\")";
 
184
                case MMGUI_DEVICE_MODE_1XRTT:
 
185
                        return "CDMA2000 1xRTT";
 
186
                case MMGUI_DEVICE_MODE_EVDO0:
 
187
                        return "CDMA2000 EVDO revision 0";
 
188
                case MMGUI_DEVICE_MODE_EVDOA:
 
189
                        return "CDMA2000 EVDO revision A";
 
190
                case MMGUI_DEVICE_MODE_EVDOB:
 
191
                        return "CDMA2000 EVDO revision B";
 
192
                case MMGUI_DEVICE_MODE_LTE:
 
193
                        return "LTE (ETSI 27.007: \"E-UTRAN\")";
 
194
                default:
 
195
                        return _("Unknown");
 
196
        }
 
197
}
 
198
 
 
199
gchar *mmgui_str_format_na_status_string(enum _mmgui_network_availability status)
 
200
{
 
201
        switch (status) {
 
202
                case MMGUI_NA_UNKNOWN:
 
203
                        return _("Unknown");
 
204
                case MMGUI_NA_AVAILABLE:
 
205
                        return _("Available");
 
206
                case MMGUI_NA_CURRENT:
 
207
                        return _("Current");
 
208
                case MMGUI_NA_FORBIDDEN:
 
209
                        return _("Forbidden");
 
210
                default:
 
211
                        return _("Unknown");
 
212
        }
 
213
}
 
214
 
 
215
gchar *mmgui_str_format_access_tech_string(enum _mmgui_access_tech status)
 
216
{
 
217
        switch (status) {
 
218
                case MMGUI_ACCESS_TECH_GSM:
 
219
                        return "GSM";
 
220
                case MMGUI_ACCESS_TECH_GSM_COMPACT:
 
221
                        return "GSM Compact";
 
222
                case MMGUI_ACCESS_TECH_UMTS:
 
223
                        return "UMTS";
 
224
                case MMGUI_ACCESS_TECH_EDGE:
 
225
                        return "EDGE";
 
226
                case MMGUI_ACCESS_TECH_HSDPA:
 
227
                        return "HSDPA";
 
228
                case MMGUI_ACCESS_TECH_HSUPA:
 
229
                        return "HSUPA";
 
230
                case MMGUI_ACCESS_TECH_HSPA:
 
231
                        return "HSPA";
 
232
                default:
 
233
                        return "Unknown";
 
234
        }
 
235
}
 
236
 
 
237
gchar *mmgui_str_format_reg_status(enum _mmgui_reg_status status)
 
238
{
 
239
        switch (status) {
 
240
                case MMGUI_REG_STATUS_IDLE:
 
241
                        return _("Not registered");
 
242
                case MMGUI_REG_STATUS_HOME:
 
243
                        return _("Home network");
 
244
                case MMGUI_REG_STATUS_SEARCHING:
 
245
                        return _("Searching");
 
246
                case MMGUI_REG_STATUS_DENIED:
 
247
                        return _("Registration denied");
 
248
                case MMGUI_REG_STATUS_UNKNOWN:
 
249
                        return _("Unknown status");
 
250
                case MMGUI_REG_STATUS_ROAMING:
 
251
                        return _("Roaming network");
 
252
                default:
 
253
                        return _("Unknown status");
 
254
        }
 
255
}