← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gnumeric/quantal

« back to all changes in this revision

Viewing changes to src/print-info.c

  • Committer: Bazaar Package Importer
  • Author(s): Gauvain Pocentek
  • Date: 2009-06-22 13:37:20 UTC
  • mfrom: (1.1.20 upstream) (2.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20090622133720-rtdazsiz2lx5q8l7
Tags: 1.9.9-1ubuntu1
* Merge from debian unstable, remaining changes:
  - Promoted gnumeric-doc to Recommends in gnumeric package for help to be
    installed automatically
  - gnumeric-gtk is a transitional package
  - gnumeric conflicts with gnumeric-gtk << 1.8.3-3ubuntu1
  - call initltool-update in po*
  - remove psiconv support (psiconv is in universe):
    o debian/control: remove B-D on libpsiconv-dev
    o debian/rules: don't pass --with-psiconv to ./configure
    o debian/gnumeric-plugins-extra.install: don't install the psiconv
      plugin

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/print-info.c
27
27
#include "gnumeric-gconf-priv.h"
28
28
#include "parse-util.h"
29
29
 
30
 
#include <goffice/app/go-doc.h>
31
 
#include <goffice/app/go-cmd-context.h>
32
 
#include <goffice/utils/go-file.h>
33
 
#include <goffice/utils/datetime.h>
34
 
#include <goffice/utils/go-glib-extras.h>
 
30
#include <goffice/goffice.h>
35
31
 
36
32
#include <glib/gi18n-lib.h>
37
33
#include <string.h>
1262
1258
        }
1263
1259
}
1264
1260
 
 
1261
GnmPageBreaks *
 
1262
gnm_page_breaks_dup_non_auto_breaks (GnmPageBreaks const *src)
 
1263
{
 
1264
        if (src != NULL) {
 
1265
                GnmPageBreaks *dst = gnm_page_breaks_new (src->is_vert);
 
1266
                GArray       *d_details = dst->details;
 
1267
                GArray const *s_details = src->details;
 
1268
                GnmPageBreak *pbreak;
 
1269
                unsigned i;
 
1270
 
 
1271
                /* no need to validate through gnm_page_breaks_append_break, just dup */
 
1272
                for (i = 0; i < s_details->len ; i++) {
 
1273
                        pbreak = &g_array_index (s_details, GnmPageBreak, i);
 
1274
                        if (pbreak->type != GNM_PAGE_BREAK_AUTO)
 
1275
                                g_array_append_val (d_details, *pbreak);
 
1276
                }
 
1277
                return dst;
 
1278
        } else
 
1279
                return NULL;
 
1280
}
 
1281
 
1265
1282
gboolean
1266
1283
gnm_page_breaks_append_break (GnmPageBreaks *breaks,
1267
1284
                              int pos,
1272
1289
 
1273
1290
        g_return_val_if_fail (breaks != NULL, FALSE);
1274
1291
 
 
1292
        if (type == GNM_PAGE_BREAK_NONE)
 
1293
                return TRUE;
 
1294
 
1275
1295
        /* Do some simple validation */
1276
1296
        if (pos < 0)
1277
1297
                return FALSE;
1289
1309
        return TRUE;
1290
1310
}
1291
1311
 
 
1312
GnmPageBreakType
 
1313
gnm_page_breaks_get_break (GnmPageBreaks *breaks,
 
1314
                           int pos)
 
1315
{
 
1316
        int i;
 
1317
 
 
1318
        if (breaks == NULL)
 
1319
                return GNM_PAGE_BREAK_NONE;
 
1320
 
 
1321
        for (i = breaks->details->len - 1; i >= 0; i--) {
 
1322
                GnmPageBreak *pbreak;
 
1323
                pbreak = &g_array_index (breaks->details, GnmPageBreak, i);
 
1324
                if (pbreak->pos < pos)
 
1325
                        return GNM_PAGE_BREAK_NONE;
 
1326
                if (pbreak->pos == pos)
 
1327
                        return (pbreak->type);
 
1328
        }
 
1329
        return GNM_PAGE_BREAK_NONE;
 
1330
}
 
1331
 
 
1332
int
 
1333
gnm_page_breaks_get_next_manual_break (GnmPageBreaks *breaks,
 
1334
                           int pos)
 
1335
{
 
1336
        guint i;
 
1337
 
 
1338
        if (breaks == NULL)
 
1339
                return -1;
 
1340
 
 
1341
        for (i = 0; i < breaks->details->len; i++) {
 
1342
                GnmPageBreak const *pbreak;
 
1343
                pbreak = &g_array_index (breaks->details, GnmPageBreak, i);
 
1344
                if (pbreak->pos > pos 
 
1345
                    && pbreak->type != GNM_PAGE_BREAK_AUTO)
 
1346
                        return pbreak->pos;
 
1347
        }
 
1348
        return -1;
 
1349
}
 
1350
 
 
1351
int
 
1352
gnm_page_breaks_get_next_break (GnmPageBreaks *breaks,
 
1353
                           int pos)
 
1354
{
 
1355
        guint i;
 
1356
 
 
1357
        if (breaks == NULL)
 
1358
                return -1;
 
1359
 
 
1360
        for (i = 0; i < breaks->details->len; i++) {
 
1361
                GnmPageBreak const *pbreak;
 
1362
                pbreak = &g_array_index (breaks->details, GnmPageBreak, i);
 
1363
                if (pbreak->pos > pos)
 
1364
                        return pbreak->pos;
 
1365
        }
 
1366
        return -1;
 
1367
}
 
1368
 
 
1369
gboolean
 
1370
gnm_page_breaks_set_break (GnmPageBreaks *breaks,
 
1371
                           int pos,
 
1372
                           GnmPageBreakType type)
 
1373
{
 
1374
        GnmPageBreak *pbreak;
 
1375
        GnmPageBreak info;
 
1376
        guint i;
 
1377
        int before = -1;
 
1378
 
 
1379
        g_return_val_if_fail (breaks != NULL, FALSE);
 
1380
 
 
1381
        /* Do some simple validation */
 
1382
        if (pos < 0)
 
1383
                return FALSE;
 
1384
        
 
1385
        if (breaks->details->len == 0 && type != GNM_PAGE_BREAK_NONE)
 
1386
                return gnm_page_breaks_append_break (breaks, pos, type);
 
1387
 
 
1388
        for (i = 0; i < breaks->details->len; i++) {
 
1389
                pbreak = &g_array_index (breaks->details, GnmPageBreak, i);
 
1390
                if (pbreak->pos == pos) {
 
1391
                        if (type == GNM_PAGE_BREAK_NONE) {
 
1392
                                g_array_remove_index (breaks->details, i);
 
1393
                        } else {
 
1394
                                pbreak->type = type;
 
1395
                        }
 
1396
                        return TRUE;
 
1397
                } else if (pbreak->pos < pos)
 
1398
                        before = (int) i;
 
1399
        }
 
1400
 
 
1401
        if (type == GNM_PAGE_BREAK_NONE)
 
1402
                return TRUE;
 
1403
 
 
1404
        info.pos   = pos;
 
1405
        info.type  = type;
 
1406
        if ((before + 1) > (int) breaks->details->len)
 
1407
                g_array_append_val (breaks->details, info);
 
1408
        else
 
1409
                g_array_insert_val (breaks->details, (before + 1), info);
 
1410
 
 
1411
        return TRUE;
 
1412
}
 
1413
 
1292
1414
/**
1293
1415
 * gnm_page_break_type_from_str
1294
1416
 * @str :
1303
1425
                return GNM_PAGE_BREAK_AUTO;
1304
1426
        if (0 == g_ascii_strcasecmp (str, "data-slice"))
1305
1427
                return GNM_PAGE_BREAK_DATA_SLICE;
1306
 
        return GNM_PAGE_BREAK_AUTO;
 
1428
        if (0 == g_ascii_strcasecmp (str, "none"))
 
1429
                return GNM_PAGE_BREAK_NONE;
 
1430
        return GNM_PAGE_BREAK_NONE;
 
1431
}
 
1432
 
 
1433
 
 
1434
/**
 
1435
 *
 
1436
 * Remove all auto page breaks
 
1437
 *
 
1438
 **/
 
1439
 
 
1440
void             
 
1441
gnm_page_breaks_clean (GnmPageBreaks *breaks)
 
1442
{
 
1443
        guint i;
 
1444
        for (i = 0; i < breaks->details->len; i++) {
 
1445
                GnmPageBreak *pbreak = &g_array_index (breaks->details, 
 
1446
                                                       GnmPageBreak, i);
 
1447
                if (pbreak->type == GNM_PAGE_BREAK_AUTO) {
 
1448
                        g_array_remove_index (breaks->details, i);
 
1449
                        i--;
 
1450
                }
 
1451
        } 
1307
1452
}