← Back to branch summary

~ubuntu-branches/ubuntu/wily/apvlv/wily

« back to all changes in this revision

Viewing changes to src/ApvlvWindow.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michael Biebl
  • Date: 2011-06-01 22:18:49 UTC
  • mfrom: (10.1.4 sid)
  • Revision ID: james.westby@ubuntu.com-20110601221849-niibd5p5i7avemy4
Tags: 0.1.1-1.1
http://bugs.debian.org/627609
* Non-maintainer upload.
* Add support for poppler >= 0.15. Patch by Pino Toscano. (Closes: #627609)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ApvlvWindow.cpp
34
34
 
35
35
#include <gtk/gtk.h>
36
36
 
37
 
#include <string.h>
38
 
 
39
37
namespace apvlv
40
 
{
 
38
  {
41
39
  ApvlvWindow *ApvlvWindow::m_curWindow = NULL;
42
40
 
43
 
    ApvlvWindow::ApvlvWindow (ApvlvCore * doc)
 
41
  ApvlvWindow::ApvlvWindow (ApvlvCore * doc)
44
42
  {
45
43
    mIsClose = false;
46
44
 
47
45
    type = AW_CORE;
48
46
    if (doc == NULL)
49
47
      {
50
 
        mCore = new ApvlvDoc (0, 0, gParams->values ("zoom"));
 
48
        mCore = new ApvlvDoc (0, 0, gParams->values ("zoom"));
51
49
      }
52
50
    else
53
51
      {
54
 
        mCore = doc;
 
52
        mCore = doc;
55
53
      }
56
54
    m_son = m_daughter = m_parent = NULL;
57
55
  }
60
58
  {
61
59
    if (mIsClose)
62
60
      {
63
 
        return;
 
61
        return;
64
62
      }
65
63
 
66
64
    debug ("delete window: %p", this);
69
67
 
70
68
    if (m_parent != NULL)
71
69
      {
72
 
        if (m_parent->m_son == this)
73
 
          {
74
 
            m_parent->m_son = NULL;
75
 
          }
76
 
        else if (m_parent->m_daughter == this)
77
 
          {
78
 
            m_parent->m_daughter = NULL;
79
 
          }
 
70
        if (m_parent->m_son == this)
 
71
          {
 
72
            m_parent->m_son = NULL;
 
73
          }
 
74
        else if (m_parent->m_daughter == this)
 
75
          {
 
76
            m_parent->m_daughter = NULL;
 
77
          }
80
78
      }
81
79
 
82
80
    if (type == AW_CORE)
83
81
      {
84
 
        mCore->inuse (false);
 
82
        mCore->inuse (false);
85
83
      }
86
84
 
87
85
    else if (type == AW_SP || type == AW_VSP)
88
86
      {
89
 
        if (m_son != NULL)
90
 
          {
91
 
            ApvlvWindow *win = m_son;
92
 
            m_son = NULL;
93
 
            delete win;
94
 
          }
95
 
        if (m_daughter != NULL)
96
 
          {
97
 
            ApvlvWindow *win = m_daughter;
98
 
            m_daughter = NULL;
99
 
            delete win;
100
 
          }
 
87
        if (m_son != NULL)
 
88
          {
 
89
            ApvlvWindow *win = m_son;
 
90
            m_son = NULL;
 
91
            delete win;
 
92
          }
 
93
        if (m_daughter != NULL)
 
94
          {
 
95
            ApvlvWindow *win = m_daughter;
 
96
            m_daughter = NULL;
 
97
            delete win;
 
98
          }
101
99
 
102
 
        g_object_unref (mPaned);
 
100
        g_object_unref (mPaned);
103
101
      }
104
102
  }
105
103
 
107
105
  {
108
106
    if (type == AW_CORE)
109
107
      {
110
 
        return mCore->widget ();
 
108
        return mCore->widget ();
111
109
      }
112
110
    else if (type == AW_SP || type == AW_VSP)
113
111
      {
114
 
        return mPaned;
 
112
        return mPaned;
115
113
      }
116
114
    else
117
115
      {
118
 
        debug ("type error: %d", type);
119
 
        return NULL;
 
116
        debug ("type error: %d", type);
 
117
        return NULL;
120
118
      }
121
119
  }
122
120
 
124
122
  {
125
123
    if (pre != NULL && pre->type == AW_CORE)
126
124
      {
127
 
        pre->mCore->setactive (false);
 
125
        pre->mCore->setactive (false);
128
126
      }
129
127
 
130
128
    if (win->type == AW_CORE)
131
129
      {
132
 
        win->mCore->setactive (true);
 
130
        win->mCore->setactive (true);
133
131
      }
134
132
 
135
133
    m_curWindow = win;
165
163
      case 'j':
166
164
      case 'h':
167
165
      case 'l':
168
 
        nwin = getneighbor (ct, key);
169
 
        if (nwin != NULL)
170
 
          {
171
 
            setcurrentWindow (this, nwin);
172
 
          }
173
 
        break;
 
166
        nwin = getneighbor (ct, key);
 
167
        if (nwin != NULL)
 
168
          {
 
169
            setcurrentWindow (this, nwin);
 
170
          }
 
171
        break;
174
172
 
175
173
      case '-':
176
 
        smaller (ct);
177
 
        break;
 
174
        smaller (ct);
 
175
        break;
178
176
 
179
177
      case '+':
180
 
        bigger (ct);
181
 
        break;
 
178
        bigger (ct);
 
179
        break;
182
180
 
183
181
      default:
184
 
        break;
 
182
        break;
185
183
      }
186
184
    return MATCH;
187
185
  }
191
189
    switch (key)
192
190
      {
193
191
      case CTRL ('w'):
194
 
        return getnext (ct);
 
192
        return getnext (ct);
195
193
      case 'k':
196
 
        return getkj (1, false);
 
194
        return getkj (1, false);
197
195
      case 'j':
198
 
        return getkj (1, true);
 
196
        return getkj (1, true);
199
197
      case 'h':
200
 
        return gethl (1, false);
 
198
        return gethl (1, false);
201
199
      case 'l':
202
 
        return gethl (1, true);
 
200
        return gethl (1, true);
203
201
      default:
204
 
        break;
 
202
        break;
205
203
      }
206
204
 
207
205
    return NULL;
215
213
    asst (this && type == AW_CORE);
216
214
    for (cw = fw = NULL, w = this; w != NULL; cw = w, w = w->m_parent)
217
215
      {
218
 
        if (w->type == AW_SP)
219
 
          {
220
 
            if ((cw == w->m_daughter && down == true)
221
 
                || (cw == w->m_son && down == false))
222
 
              {
223
 
                continue;
224
 
              }
225
 
            else
226
 
              {
227
 
                fw = down ? w->m_daughter : w->m_son;
228
 
                break;
229
 
              }
230
 
          }
231
 
        else if (w->type == AW_VSP)
232
 
          {
233
 
            if (cw != NULL && cw == w->m_daughter)
234
 
              {
235
 
                right = true;
236
 
              }
237
 
            else
238
 
              {
239
 
                right = false;
240
 
              }
241
 
          }
 
216
        if (w->type == AW_SP)
 
217
          {
 
218
            if ((cw == w->m_daughter && down == true)
 
219
                || (cw == w->m_son && down == false))
 
220
              {
 
221
                continue;
 
222
              }
 
223
            else
 
224
              {
 
225
                fw = down ? w->m_daughter : w->m_son;
 
226
                break;
 
227
              }
 
228
          }
 
229
        else if (w->type == AW_VSP)
 
230
          {
 
231
            if (cw != NULL && cw == w->m_daughter)
 
232
              {
 
233
                right = true;
 
234
              }
 
235
            else
 
236
              {
 
237
                right = false;
 
238
              }
 
239
          }
242
240
      }
243
241
 
244
242
    for (nw = w = fw; w != NULL;)
245
243
      {
246
 
        if (w->type == AW_CORE)
247
 
          {
248
 
            nw = w;
249
 
            break;
250
 
          }
251
 
        else if (w->type == AW_SP)
252
 
          {
253
 
            w = down ? w->m_son : w->m_daughter;
254
 
          }
255
 
        else if (w->type == AW_VSP)
256
 
          {
257
 
            w = right ? w->m_daughter : w->m_son;
258
 
          }
259
 
        else
260
 
          {
261
 
            debug ("error type: %d", w->type);
262
 
            return NULL;
263
 
          }
 
244
        if (w->type == AW_CORE)
 
245
          {
 
246
            nw = w;
 
247
            break;
 
248
          }
 
249
        else if (w->type == AW_SP)
 
250
          {
 
251
            w = down ? w->m_son : w->m_daughter;
 
252
          }
 
253
        else if (w->type == AW_VSP)
 
254
          {
 
255
            w = right ? w->m_daughter : w->m_son;
 
256
          }
 
257
        else
 
258
          {
 
259
            debug ("error type: %d", w->type);
 
260
            return NULL;
 
261
          }
264
262
      }
265
263
 
266
264
    return nw;
274
272
    asst (this && type == AW_CORE);
275
273
    for (cw = fw = NULL, w = this; w != NULL; cw = w, w = w->m_parent)
276
274
      {
277
 
        if (w->type == AW_VSP)
278
 
          {
279
 
            if ((cw == w->m_daughter && right == true)
280
 
                || (cw == w->m_son && right == false))
281
 
              {
282
 
                continue;
283
 
              }
284
 
            else
285
 
              {
286
 
                fw = right ? w->m_daughter : w->m_son;
287
 
                break;
288
 
              }
289
 
          }
290
 
        else if (w->type == AW_SP)
291
 
          {
292
 
            if (cw != NULL && cw == w->m_daughter)
293
 
              {
294
 
                down = true;
295
 
              }
296
 
            else
297
 
              {
298
 
                down = false;
299
 
              }
300
 
          }
 
275
        if (w->type == AW_VSP)
 
276
          {
 
277
            if ((cw == w->m_daughter && right == true)
 
278
                || (cw == w->m_son && right == false))
 
279
              {
 
280
                continue;
 
281
              }
 
282
            else
 
283
              {
 
284
                fw = right ? w->m_daughter : w->m_son;
 
285
                break;
 
286
              }
 
287
          }
 
288
        else if (w->type == AW_SP)
 
289
          {
 
290
            if (cw != NULL && cw == w->m_daughter)
 
291
              {
 
292
                down = true;
 
293
              }
 
294
            else
 
295
              {
 
296
                down = false;
 
297
              }
 
298
          }
301
299
      }
302
300
 
303
301
    for (nw = w = fw; w != NULL;)
304
302
      {
305
 
        if (w->type == AW_CORE)
306
 
          {
307
 
            nw = w;
308
 
            break;
309
 
          }
310
 
        else if (w->type == AW_VSP)
311
 
          {
312
 
            w = right ? w->m_son : w->m_daughter;
313
 
          }
314
 
        else if (w->type == AW_SP)
315
 
          {
316
 
            w = down ? w->m_daughter : w->m_son;
317
 
          }
318
 
        else
319
 
          {
320
 
            debug ("error type: %d", w->type);
321
 
            return NULL;
322
 
          }
 
303
        if (w->type == AW_CORE)
 
304
          {
 
305
            nw = w;
 
306
            break;
 
307
          }
 
308
        else if (w->type == AW_VSP)
 
309
          {
 
310
            w = right ? w->m_son : w->m_daughter;
 
311
          }
 
312
        else if (w->type == AW_SP)
 
313
          {
 
314
            w = down ? w->m_daughter : w->m_son;
 
315
          }
 
316
        else
 
317
          {
 
318
            debug ("error type: %d", w->type);
 
319
            return NULL;
 
320
          }
323
321
      }
324
322
 
325
323
    return nw;
330
328
    ApvlvWindow *n = getkj (num, true);
331
329
    if (n == NULL)
332
330
      {
333
 
        n = gethl (num, true);
334
 
        if (n == NULL)
335
 
          {
336
 
            n = gethl (num, false);
337
 
            if (n == NULL)
338
 
              n = getkj (num, false);
339
 
          }
 
331
        n = gethl (num, true);
 
332
        if (n == NULL)
 
333
          {
 
334
            n = gethl (num, false);
 
335
            if (n == NULL)
 
336
              n = getkj (num, false);
 
337
          }
340
338
      }
341
339
    return n;
342
340
  }
349
347
 
350
348
    if (doc == mCore)
351
349
      {
352
 
        debug ("can't birth with orign doc, copy it");
353
 
        doc = NULL;
354
 
      }
355
 
 
356
 
    if (doc == NULL)
357
 
      {
358
 
        doc = mCore->copy ();
359
 
        gView->regloaded (doc);
360
 
      }
361
 
 
362
 
    if (doc == NULL)
363
 
      {
364
 
        gView->errormessage ("can't split");
365
 
        return this;
 
350
        debug ("can't birth with orign doc, copy it");
 
351
        doc = NULL;
 
352
      }
 
353
 
 
354
    if (doc == NULL)
 
355
      {
 
356
        doc = mCore->copy ();
 
357
        gView->regloaded (doc);
 
358
      }
 
359
 
 
360
    if (doc == NULL)
 
361
      {
 
362
        gView->errormessage ("can't split");
 
363
        return this;
366
364
      }
367
365
 
368
366
    ApvlvWindow *nwindow = new ApvlvWindow (doc);
376
374
    mPaned = vsp == false ? gtk_vpaned_new () : gtk_hpaned_new ();
377
375
    g_object_ref (mPaned);
378
376
    g_signal_connect (G_OBJECT (mPaned), "button-release-event",
379
 
                      G_CALLBACK (apvlv_window_paned_resized_cb), this);
 
377
                      G_CALLBACK (apvlv_window_paned_resized_cb), this);
380
378
 
381
379
    if (m_parent)
382
380
      {
383
 
        void (*panedcb) (GtkPaned *, GtkWidget *);
384
 
        GtkWidget *parent = m_parent->mPaned;
385
 
        if (gtk_paned_get_child1 (GTK_PANED (parent)) == widget ())
386
 
          {
387
 
            panedcb = gtk_paned_add1;
388
 
          }
389
 
        else
390
 
          {
391
 
            panedcb = gtk_paned_add2;
392
 
          }
 
381
        void (*panedcb) (GtkPaned *, GtkWidget *);
 
382
        GtkWidget *parent = m_parent->mPaned;
 
383
        if (gtk_paned_get_child1 (GTK_PANED (parent)) == widget ())
 
384
          {
 
385
            panedcb = gtk_paned_add1;
 
386
          }
 
387
        else
 
388
          {
 
389
            panedcb = gtk_paned_add2;
 
390
          }
393
391
 
394
 
        gtk_container_remove (GTK_CONTAINER (parent), widget ());
395
 
        panedcb (GTK_PANED (parent), mPaned);
 
392
        gtk_container_remove (GTK_CONTAINER (parent), widget ());
 
393
        panedcb (GTK_PANED (parent), mPaned);
396
394
      }
397
395
    else
398
396
      {
399
 
        replace_widget (widget (), mPaned);
 
397
        replace_widget (widget (), mPaned);
400
398
      }
401
399
 
402
400
    gtk_paned_pack1 (GTK_PANED (mPaned), nwindow->widget (), TRUE, TRUE);
405
403
    type = vsp == false ? AW_SP : AW_VSP;
406
404
    if (type == AW_SP)
407
405
      {
408
 
        nwindow->setsize (mWidth, mHeight / 2);
409
 
        nwindow2->setsize (mWidth, mHeight / 2);
 
406
        nwindow->setsize (mWidth, mHeight / 2);
 
407
        nwindow2->setsize (mWidth, mHeight / 2);
410
408
      }
411
409
    else if (type == AW_VSP)
412
410
      {
413
 
        nwindow->setsize (mWidth / 2, mHeight);
414
 
        nwindow2->setsize (mWidth / 2, mHeight);
 
411
        nwindow->setsize (mWidth / 2, mHeight);
 
412
        nwindow2->setsize (mWidth / 2, mHeight);
415
413
      }
416
414
 
417
415
    gtk_widget_show_all (mPaned);
430
428
 
431
429
    if (m_parent)
432
430
      {
433
 
        void (*panedcb) (GtkPaned *, GtkWidget *);
434
 
        GtkWidget *parent = m_parent->mPaned;
435
 
        if (gtk_paned_get_child1 (GTK_PANED (parent)) == mPaned)
436
 
          {
437
 
            panedcb = gtk_paned_add1;
438
 
          }
439
 
        else
440
 
          {
441
 
            panedcb = gtk_paned_add2;
442
 
          }
 
431
        void (*panedcb) (GtkPaned *, GtkWidget *);
 
432
        GtkWidget *parent = m_parent->mPaned;
 
433
        if (gtk_paned_get_child1 (GTK_PANED (parent)) == mPaned)
 
434
          {
 
435
            panedcb = gtk_paned_add1;
 
436
          }
 
437
        else
 
438
          {
 
439
            panedcb = gtk_paned_add2;
 
440
          }
443
441
 
444
 
        gtk_container_remove (GTK_CONTAINER (mPaned), child->widget ());
445
 
        gtk_container_remove (GTK_CONTAINER (parent), mPaned);
446
 
        panedcb (GTK_PANED (parent), child->widget ());
 
442
        gtk_container_remove (GTK_CONTAINER (mPaned), child->widget ());
 
443
        gtk_container_remove (GTK_CONTAINER (parent), mPaned);
 
444
        panedcb (GTK_PANED (parent), child->widget ());
447
445
      }
448
446
    else
449
447
      {
450
 
        gtk_container_remove (GTK_CONTAINER (mPaned), child->widget ());
451
 
        replace_widget (mPaned, child->widget ());
 
448
        gtk_container_remove (GTK_CONTAINER (mPaned), child->widget ());
 
449
        replace_widget (mPaned, child->widget ());
452
450
      }
453
451
 
454
452
    if (child->type == AW_CORE)
455
453
      {
456
 
        ApvlvCore *doc = child->getCore ();
457
 
        type = AW_CORE;
458
 
        mCore = doc;
 
454
        ApvlvCore *doc = child->getCore ();
 
455
        type = AW_CORE;
 
456
        mCore = doc;
459
457
      }
460
458
    else if (child->type == AW_SP || child->type == AW_VSP)
461
459
      {
462
 
        type = child->type;
463
 
        mPaned = child->mPaned;
464
 
        m_son = child->m_son;
465
 
        m_son->m_parent = this;
466
 
        m_daughter = child->m_daughter;
467
 
        m_daughter->m_parent = this;
468
 
        child->type = AW_NONE;
 
460
        type = child->type;
 
461
        mPaned = child->mPaned;
 
462
        m_son = child->m_son;
 
463
        m_son->m_parent = this;
 
464
        m_daughter = child->m_daughter;
 
465
        m_daughter->m_parent = this;
 
466
        child->type = AW_NONE;
469
467
      }
470
468
 
471
469
    gtk_widget_show_all (widget ());
490
488
  {
491
489
    if (width)
492
490
      {
493
 
        *width = mWidth;
 
491
        *width = mWidth;
494
492
      }
495
493
    if (height)
496
494
      {
497
 
        *height = mHeight;
 
495
        *height = mHeight;
498
496
      }
499
497
  }
500
498
 
506
504
 
507
505
    if (type == AW_CORE)
508
506
      {
509
 
        mCore->setsize (mWidth, mHeight);
 
507
        mCore->setsize (mWidth, mHeight);
510
508
      }
511
509
    else if (type == AW_SP || type == AW_VSP)
512
510
      {
513
 
        g_timeout_add (50, apvlv_window_resize_children_cb, this);
 
511
        g_timeout_add (50, apvlv_window_resize_children_cb, this);
514
512
      }
515
513
  }
516
514
 
519
517
    debug ("widget (): %p, doc->widget (): %p", widget (), doc->widget ());
520
518
    if (type == AW_CORE)
521
519
      {
522
 
        mCore->inuse (false);
 
520
        mCore->inuse (false);
523
521
      }
524
522
    replace_widget (widget (), doc->widget ());
525
523
    doc->inuse (true);
561
559
  }
562
560
 
563
561
  gboolean
564
 
    ApvlvWindow::apvlv_window_paned_resized_cb (GtkWidget * wid,
565
 
                                                GdkEventButton * but,
566
 
                                                ApvlvWindow * win)
 
562
  ApvlvWindow::apvlv_window_paned_resized_cb (GtkWidget * wid,
 
563
      GdkEventButton * but,
 
564
      ApvlvWindow * win)
567
565
  {
568
566
    win->resize_children ();
569
567
    return FALSE;
579
577
    int ms = ma - mi;
580
578
    if (ms != 0)
581
579
      {
582
 
        if (type == AW_SP)
583
 
          {
584
 
            mh1 = (mHeight * (mv - mi)) / ms - 1;
585
 
            mh2 = mHeight - mh1 - 1;
586
 
          }
587
 
        else if (type == AW_VSP)
588
 
          {
589
 
            mw1 = (mWidth * (mv - mi)) / ms - 1;
590
 
            mw2 = mWidth - mw1 - 1;
591
 
          }
592
 
 
593
 
        m_son->setsize (mw1, mh1);
594
 
        m_daughter->setsize (mw2, mh2);
595
 
 
596
 
        return TRUE;
 
580
        if (type == AW_SP)
 
581
          {
 
582
            mh1 = (mHeight * (mv - mi)) / ms - 1;
 
583
            mh2 = mHeight - mh1 - 1;
 
584
          }
 
585
        else if (type == AW_VSP)
 
586
          {
 
587
            mw1 = (mWidth * (mv - mi)) / ms - 1;
 
588
            mw2 = mWidth - mw1 - 1;
 
589
          }
 
590
 
 
591
        m_son->setsize (mw1, mh1);
 
592
        m_daughter->setsize (mw2, mh2);
 
593
 
 
594
        return TRUE;
597
595
      }
598
596
    else
599
597
      {
600
 
        return FALSE;
 
598
        return FALSE;
601
599
      }
602
600
  }
603
601