src/plugins/python/clawsmailmodule.c

   1 /* Python plugin for Claws-Mail
   2  * Copyright (C) 2009-2012 Holger Berndt
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "clawsmailmodule.h"
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include "config.h"
  22 #include "claws-features.h"
  23 #endif
  24
  25 #include <glib.h>
  26 #include <glib/gi18n.h>
  27
  28 #include "nodetype.h"
  29 #include "composewindowtype.h"
  30 #include "folderpropertiestype.h"
  31 #include "foldertype.h"
  32 #include "messageinfotype.h"
  33 #include "accounttype.h"
  34 #include "mailboxtype.h"
  35
  36 #include <pygobject.h>
  37 #include <pygtk/pygtk.h>
  38
  39 #include "main.h"
  40 #include "mainwindow.h"
  41 #include "summaryview.h"
  42 #include "quicksearch.h"
  43 #include "toolbar.h"
  44 #include "prefs_common.h"
  45 #include "common/tags.h"
  46 #include "account.h"
  47
  48 #include <glib.h>
  49
  50 static PyObject *cm_module = NULL;
  51
  52 PyObject* get_gobj_from_address(gpointer addr)
  53 {
  54   GObject *obj;
  55
  56   if (!G_IS_OBJECT(addr))
  57       return NULL;
  58
  59   obj = G_OBJECT(addr);
  60
  61   if (!obj)
  62       return NULL;
  63
  64   return pygobject_new(obj);
  65 }
  66
  67 static PyObject* private_wrap_gobj(PyObject *self, PyObject *args)
  68 {
  69     void *addr;
  70
  71     if (!PyArg_ParseTuple(args, "l", &addr))
  72         return NULL;
  73
  74     return get_gobj_from_address(addr);
  75 }
  76
  77 static PyObject *get_mainwindow_action_group(PyObject *self, PyObject *args)
  78 {
  79   MainWindow *mainwin;
  80
  81   mainwin =  mainwindow_get_mainwindow();
  82   if(mainwin)
  83     return get_gobj_from_address(mainwin->action_group);
  84   else
  85     return NULL;
  86 }
  87
  88 static PyObject *get_mainwindow_ui_manager(PyObject *self, PyObject *args)
  89 {
  90   MainWindow *mainwin;
  91
  92   mainwin =  mainwindow_get_mainwindow();
  93   if(mainwin)
  94     return get_gobj_from_address(mainwin->ui_manager);
  95   else
  96     return NULL;
  97 }
  98
  99 static PyObject *get_folderview_selected_folder(PyObject *self, PyObject *args)
 100 {
 101   MainWindow *mainwin;
 102
 103   mainwin =  mainwindow_get_mainwindow();
 104   if(mainwin && mainwin->folderview) {
 105     FolderItem *item;
 106     item = folderview_get_selected_item(mainwin->folderview);
 107     if(item)
 108       return clawsmail_folder_new(item);
 109   }
 110   Py_RETURN_NONE;
 111 }
 112
 113 static PyObject *get_folderview_selected_mailbox(PyObject *self, PyObject *args)
 114 {
 115   MainWindow *mainwin;
 116
 117   mainwin =  mainwindow_get_mainwindow();
 118   if(mainwin && mainwin->folderview) {
 119     FolderItem *item;
 120     item = folderview_get_selected_item(mainwin->folderview);
 121     if(item) {
 122       gchar *id;
 123       id = folder_item_get_identifier(item);
 124       /* If there is an id, it's a folder, not a mailbox */
 125       if(id) {
 126         g_free(id);
 127         Py_RETURN_NONE;
 128       }
 129       else
 130         return clawsmail_mailbox_new(item->folder);
 131     }
 132   }
 133   Py_RETURN_NONE;
 134 }
 135
 136 static PyObject *folderview_select_row(PyObject *self, PyObject *args)
 137 {
 138   MainWindow *mainwin;
 139   gboolean ok;
 140
 141   ok = TRUE;
 142   mainwin =  mainwindow_get_mainwindow();
 143   if(mainwin && mainwin->folderview) {
 144     PyObject *arg;
 145     arg = PyTuple_GetItem(args, 0);
 146     if(!arg)
 147       return NULL;
 148     Py_INCREF(arg);
 149
 150     if(clawsmail_folder_check(arg)) {
 151       FolderItem *item;
 152       item = clawsmail_folder_get_item(arg);
 153       if(item)
 154         folderview_select(mainwin->folderview, item);
 155     }
 156     else if(clawsmail_mailbox_check(arg)) {
 157       Folder *folder;
 158       folder = clawsmail_mailbox_get_folder(arg);
 159       if(folder && folder->node) {
 160         folderview_select(mainwin->folderview, folder->node->data);
 161       }
 162     }
 163     else {
 164       PyErr_SetString(PyExc_TypeError, "Bad argument type");
 165       ok = FALSE;
 166     }
 167
 168     Py_DECREF(arg);
 169   }
 170   if(ok)
 171     Py_RETURN_NONE;
 172   else
 173     return NULL;
 174 }
 175
 176 static gboolean setup_folderitem_node(GNode *item_node, GNode *item_parent, PyObject **pyparent)
 177 {
 178   PyObject *pynode, *children;
 179   int retval, n_children, i_child;
 180   PyObject *folder;
 181
 182   /* create a python node for the folderitem node */
 183   pynode = clawsmail_node_new(cm_module);
 184   if(!pynode)
 185     return FALSE;
 186
 187   /* store Folder in pynode */
 188   folder = clawsmail_folder_new(item_node->data);
 189   retval = PyObject_SetAttrString(pynode, "data", folder);
 190   Py_DECREF(folder);
 191   if(retval == -1) {
 192     Py_DECREF(pynode);
 193     return FALSE;
 194   }
 195
 196   if(pyparent && *pyparent) {
 197     /* add this node to the parent's childs */
 198     children = PyObject_GetAttrString(*pyparent, "children");
 199     retval = PyList_Append(children, pynode);
 200     Py_DECREF(children);
 201
 202     if(retval == -1) {
 203       Py_DECREF(pynode);
 204       return FALSE;
 205     }
 206   }
 207   else if(pyparent) {
 208     *pyparent = pynode;
 209     Py_INCREF(pynode);
 210   }
 211
 212   /* call this function recursively for all children of the new node */
 213   n_children = g_node_n_children(item_node);
 214   for(i_child = 0; i_child < n_children; i_child++) {
 215     if(!setup_folderitem_node(g_node_nth_child(item_node, i_child), item_node, &pynode)) {
 216       Py_DECREF(pynode);
 217       return FALSE;
 218     }
 219   }
 220
 221   Py_DECREF(pynode);
 222   return TRUE;
 223 }
 224
 225 static PyObject* get_folder_tree_from_folder(Folder *folder)
 226 {
 227   if(folder->node) {
 228     PyObject *root;
 229     int n_children, i_child;
 230
 231     /* create root nodes */
 232     root = clawsmail_node_new(cm_module);
 233     if(!root)
 234       return NULL;
 235
 236     n_children = g_node_n_children(folder->node);
 237     for(i_child = 0; i_child < n_children; i_child++) {
 238       if(!setup_folderitem_node(g_node_nth_child(folder->node, i_child), folder->node, &root)) {
 239         Py_DECREF(root);
 240         return NULL;
 241       }
 242     }
 243     return root;
 244   }
 245   return NULL;
 246 }
 247
 248 static PyObject* get_folder_tree_from_account_name(const char *str)
 249 {
 250   PyObject *result;
 251   GList *walk;
 252
 253   result = Py_BuildValue("[]");
 254   if(!result)
 255     return NULL;
 256
 257   for(walk = folder_get_list(); walk; walk = walk->next) {
 258     Folder *folder = walk->data;
 259     if(!str || !g_strcmp0(str, folder->name)) {
 260       PyObject *tree_from_folder;
 261       tree_from_folder = get_folder_tree_from_folder(folder);
 262       if(tree_from_folder) {
 263         int retval;
 264         retval = PyList_Append(result, tree_from_folder);
 265         Py_DECREF(tree_from_folder);
 266         if(retval == -1) {
 267           Py_DECREF(result);
 268           return NULL;
 269         }
 270       }
 271       else {
 272         Py_DECREF(result);
 273         return NULL;
 274       }
 275     }
 276   }
 277   return result;
 278 }
 279
 280 static PyObject* get_folder_tree_from_folderitem(FolderItem *item)
 281 {
 282   PyObject *result;
 283   GList *walk;
 284
 285   for(walk = folder_get_list(); walk; walk = walk->next) {
 286     Folder *folder = walk->data;
 287     if(folder->node) {
 288       GNode *root_node;
 289
 290       root_node = g_node_find(folder->node, G_PRE_ORDER, G_TRAVERSE_ALL, item);
 291       if(!root_node)
 292         continue;
 293
 294       result = NULL;
 295       if(!setup_folderitem_node(root_node, NULL, &result))
 296         return NULL;
 297       else
 298         return result;
 299     }
 300   }
 301
 302   PyErr_SetString(PyExc_LookupError, "Folder not found");
 303   return NULL;
 304 }
 305
 306 static PyObject* get_folder_tree(PyObject *self, PyObject *args)
 307 {
 308   PyObject *arg;
 309   PyObject *result;
 310   int retval;
 311
 312   Py_INCREF(Py_None);
 313   arg = Py_None;
 314   retval = PyArg_ParseTuple(args, "|O", &arg);
 315   Py_DECREF(Py_None);
 316   if(!retval)
 317     return NULL;
 318
 319   /* calling possibilities:
 320    * nothing, the mailbox name in a string, a Folder object */
 321
 322   /* no arguments: build up a list of folder trees */
 323   if(PyTuple_Size(args) == 0) {
 324     result = get_folder_tree_from_account_name(NULL);
 325   }
 326   else if(PyString_Check(arg)){
 327     const char *str;
 328     str = PyString_AsString(arg);
 329     if(!str)
 330       return NULL;
 331
 332     result = get_folder_tree_from_account_name(str);
 333   }
 334   else if(PyObject_TypeCheck(arg, clawsmail_folder_get_type_object())) {
 335     result = get_folder_tree_from_folderitem(clawsmail_folder_get_item(arg));
 336   }
 337   else if(clawsmail_mailbox_check(arg)) {
 338     result = get_folder_tree_from_folder(clawsmail_mailbox_get_folder(arg));
 339   }
 340   else {
 341     PyErr_SetString(PyExc_TypeError, "Parameter must be nothing, a Folder object, a Mailbox object, or a mailbox name string.");
 342     return NULL;
 343   }
 344
 345   return result;
 346 }
 347
 348 static PyObject* quicksearch_search(PyObject *self, PyObject *args)
 349 {
 350   const char *string;
 351   int searchtype;
 352   QuickSearch *qs;
 353   MainWindow *mainwin;
 354
 355   /* must be given exactly one argument, which is a string */
 356   searchtype = prefs_common_get_prefs()->summary_quicksearch_type;
 357   if(!PyArg_ParseTuple(args, "s|i", &string, &searchtype))
 358     return NULL;
 359
 360   mainwin = mainwindow_get_mainwindow();
 361   if(!mainwin || !mainwin->summaryview || !mainwin->summaryview->quicksearch) {
 362     PyErr_SetString(PyExc_LookupError, "Quicksearch not found");
 363     return NULL;
 364   }
 365
 366   qs = mainwin->summaryview->quicksearch;
 367   quicksearch_set(qs, searchtype, string);
 368
 369   Py_INCREF(Py_None);
 370   return Py_None;
 371 }
 372
 373 static PyObject* quicksearch_clear(PyObject *self, PyObject *args)
 374 {
 375   QuickSearch *qs;
 376   MainWindow *mainwin;
 377
 378   mainwin = mainwindow_get_mainwindow();
 379   if(!mainwin || !mainwin->summaryview || !mainwin->summaryview->quicksearch) {
 380     PyErr_SetString(PyExc_LookupError, "Quicksearch not found");
 381     return NULL;
 382   }
 383
 384   qs = mainwin->summaryview->quicksearch;
 385   quicksearch_set(qs, prefs_common_get_prefs()->summary_quicksearch_type, "");
 386
 387   Py_INCREF(Py_None);
 388   return Py_None;
 389 }
 390
 391 static PyObject* summaryview_select_messages(PyObject *self, PyObject *args)
 392 {
 393   PyObject *olist;
 394   MainWindow *mainwin;
 395   Py_ssize_t size, iEl;
 396   GSList *msginfos;
 397
 398   mainwin = mainwindow_get_mainwindow();
 399   if(!mainwin || !mainwin->summaryview) {
 400     PyErr_SetString(PyExc_LookupError, "SummaryView not found");
 401     return NULL;
 402   }
 403
 404   if(!PyArg_ParseTuple(args, "O!", &PyList_Type, &olist)) {
 405     PyErr_SetString(PyExc_LookupError, "Argument must be a list of MessageInfo objects.");
 406     return NULL;
 407   }
 408
 409   msginfos = NULL;
 410   size = PyList_Size(olist);
 411   for(iEl = 0; iEl < size; iEl++) {
 412     PyObject *element = PyList_GET_ITEM(olist, iEl);
 413
 414     if(!element || !PyObject_TypeCheck(element, clawsmail_messageinfo_get_type_object())) {
 415       PyErr_SetString(PyExc_LookupError, "Argument must be a list of MessageInfo objects.");
 416       return NULL;
 417     }
 418
 419     msginfos = g_slist_prepend(msginfos, clawsmail_messageinfo_get_msginfo(element));
 420   }
 421
 422   summary_unselect_all(mainwin->summaryview);
 423   summary_select_by_msg_list(mainwin->summaryview, msginfos);
 424   g_slist_free(msginfos);
 425
 426   Py_INCREF(Py_None);
 427   return Py_None;
 428 }
 429
 430 static PyObject* get_summaryview_selected_message_list(PyObject *self, PyObject *args)
 431 {
 432   MainWindow *mainwin;
 433   GSList *list, *walk;
 434   PyObject *result;
 435
 436   mainwin = mainwindow_get_mainwindow();
 437   if(!mainwin || !mainwin->summaryview) {
 438     PyErr_SetString(PyExc_LookupError, "SummaryView not found");
 439     return NULL;
 440   }
 441
 442   result = Py_BuildValue("[]");
 443   if(!result)
 444     return NULL;
 445
 446   list = summary_get_selected_msg_list(mainwin->summaryview);
 447   for(walk = list; walk; walk = walk->next) {
 448     PyObject *msg;
 449     msg = clawsmail_messageinfo_new(walk->data);
 450     if(PyList_Append(result, msg) == -1) {
 451       Py_DECREF(result);
 452       return NULL;
 453     }
 454   }
 455   g_slist_free(list);
 456
 457   return result;
 458 }
 459
 460 static PyObject* is_exiting(PyObject *self, PyObject *args)
 461 {
 462   if(claws_is_exiting())
 463     Py_RETURN_TRUE;
 464   else
 465     Py_RETURN_FALSE;
 466 }
 467
 468 static PyObject* get_tags(PyObject *self, PyObject *args)
 469 {
 470   Py_ssize_t num_tags;
 471   PyObject *tags_tuple;
 472   GSList *tags_list;
 473
 474   tags_list = tags_get_list();
 475   num_tags = g_slist_length(tags_list);
 476
 477   tags_tuple = PyTuple_New(num_tags);
 478   if(tags_tuple != NULL) {
 479     Py_ssize_t iTag;
 480     PyObject *tag_object;
 481     GSList *walk;
 482
 483     iTag = 0;
 484     for(walk = tags_list; walk; walk = walk->next) {
 485       tag_object = Py_BuildValue("s", tags_get_tag(GPOINTER_TO_INT(walk->data)));
 486       if(tag_object == NULL) {
 487         Py_DECREF(tags_tuple);
 488         return NULL;
 489       }
 490       PyTuple_SET_ITEM(tags_tuple, iTag++, tag_object);
 491     }
 492   }
 493
 494   g_slist_free(tags_list);
 495
 496   return tags_tuple;
 497 }
 498
 499 static PyObject* get_accounts(PyObject *self, PyObject *args)
 500 {
 501   PyObject *accounts_tuple;
 502   GList *accounts_list;
 503   GList *walk;
 504
 505   accounts_list = account_get_list();
 506
 507   accounts_tuple = PyTuple_New(g_list_length(accounts_list));
 508   if(accounts_tuple) {
 509     PyObject *account_object;
 510     Py_ssize_t iAccount;
 511
 512     iAccount = 0;
 513     for(walk = accounts_list; walk; walk = walk->next) {
 514       account_object = clawsmail_account_new(walk->data);
 515       if(account_object == NULL) {
 516         Py_DECREF(accounts_tuple);
 517         return NULL;
 518       }
 519       PyTuple_SET_ITEM(accounts_tuple, iAccount++, account_object);
 520     }
 521   }
 522
 523   return accounts_tuple;
 524 }
 525
 526 static PyObject* get_mailboxes(PyObject *self, PyObject *args)
 527 {
 528   PyObject *mailboxes_tuple;
 529   GList *mailboxes_list;
 530   GList *walk;
 531
 532   mailboxes_list = folder_get_list();
 533
 534   mailboxes_tuple = PyTuple_New(g_list_length(mailboxes_list));
 535   if(mailboxes_tuple) {
 536     PyObject *mailbox_object;
 537     Py_ssize_t iMailbox;
 538
 539     iMailbox = 0;
 540     for(walk = mailboxes_list; walk; walk = walk->next) {
 541       mailbox_object = clawsmail_mailbox_new(walk->data);
 542       if(mailbox_object == NULL) {
 543         Py_DECREF(mailboxes_tuple);
 544         return NULL;
 545       }
 546       PyTuple_SET_ITEM(mailboxes_tuple, iMailbox++, mailbox_object);
 547     }
 548   }
 549
 550   return mailboxes_tuple;
 551 }
 552
 553
 554 static PyObject* make_sure_tag_exists(PyObject *self, PyObject *args)
 555 {
 556   int retval;
 557   const char *tag_str;
 558
 559   retval = PyArg_ParseTuple(args, "s", &tag_str);
 560   if(!retval)
 561     return NULL;
 562
 563   if(IS_NOT_RESERVED_TAG(tag_str) == FALSE) {
 564     /* tag name is reserved, raise KeyError */
 565     PyErr_SetString(PyExc_ValueError, "Tag name is reserved");
 566     return NULL;
 567   }
 568
 569   tags_add_tag(tag_str);
 570
 571   Py_RETURN_NONE;
 572 }
 573
 574 static PyObject* delete_tag(PyObject *self, PyObject *args)
 575 {
 576   int retval;
 577   const char *tag_str;
 578   gint tag_id;
 579   MainWindow *mainwin;
 580
 581   retval = PyArg_ParseTuple(args, "s", &tag_str);
 582   if(!retval)
 583     return NULL;
 584
 585   tag_id = tags_get_id_for_str(tag_str);
 586   if(tag_id == -1) {
 587     PyErr_SetString(PyExc_KeyError, "Tag does not exist");
 588     return NULL;
 589   }
 590
 591   tags_remove_tag(tag_id);
 592
 593   /* update display */
 594   mainwin = mainwindow_get_mainwindow();
 595   if(mainwin)
 596     summary_redisplay_msg(mainwin->summaryview);
 597
 598   Py_RETURN_NONE;
 599 }
 600
 601
 602 static PyObject* rename_tag(PyObject *self, PyObject *args)
 603 {
 604   int retval;
 605   const char *old_tag_str;
 606   const char *new_tag_str;
 607   gint tag_id;
 608   MainWindow *mainwin;
 609
 610   retval = PyArg_ParseTuple(args, "ss", &old_tag_str, &new_tag_str);
 611   if(!retval)
 612     return NULL;
 613
 614   if((IS_NOT_RESERVED_TAG(new_tag_str) == FALSE) ||(IS_NOT_RESERVED_TAG(old_tag_str) == FALSE)) {
 615     PyErr_SetString(PyExc_ValueError, "Tag name is reserved");
 616     return NULL;
 617   }
 618
 619   tag_id = tags_get_id_for_str(old_tag_str);
 620   if(tag_id == -1) {
 621     PyErr_SetString(PyExc_KeyError, "Tag does not exist");
 622     return NULL;
 623   }
 624
 625   tags_update_tag(tag_id, new_tag_str);
 626
 627   /* update display */
 628   mainwin = mainwindow_get_mainwindow();
 629   if(mainwin)
 630     summary_redisplay_msg(mainwin->summaryview);
 631
 632   Py_RETURN_NONE;
 633 }
 634
 635 static gboolean get_message_list_for_move_or_copy(PyObject *messagelist, PyObject *folder, GSList **list)
 636 {
 637   Py_ssize_t size, iEl;
 638   FolderItem *folderitem;
 639
 640   *list = NULL;
 641
 642   folderitem = clawsmail_folder_get_item(folder);
 643   if(!folderitem) {
 644     PyErr_SetString(PyExc_LookupError, "Brokern Folder object.");
 645     return FALSE;
 646   }
 647
 648   size = PyList_Size(messagelist);
 649   for(iEl = 0; iEl < size; iEl++) {
 650     PyObject *element = PyList_GET_ITEM(messagelist, iEl);
 651     MsgInfo *msginfo;
 652
 653     if(!element || !PyObject_TypeCheck(element, clawsmail_messageinfo_get_type_object())) {
 654       PyErr_SetString(PyExc_TypeError, "Argument must be a list of MessageInfo objects.");
 655       return FALSE;
 656     }
 657
 658     msginfo = clawsmail_messageinfo_get_msginfo(element);
 659     if(!msginfo) {
 660       PyErr_SetString(PyExc_LookupError, "Broken MessageInfo object.");
 661       return FALSE;
 662     }
 663
 664     procmsg_msginfo_set_to_folder(msginfo, folderitem);
 665     *list = g_slist_prepend(*list, msginfo);
 666   }
 667
 668   return TRUE;
 669 }
 670
 671 static PyObject* move_or_copy_messages(PyObject *self, PyObject *args, gboolean move)
 672 {
 673   PyObject *messagelist;
 674   PyObject *folder;
 675   int retval;
 676   GSList *list = NULL;
 677
 678   retval = PyArg_ParseTuple(args, "O!O!",
 679     &PyList_Type, &messagelist,
 680     clawsmail_folder_get_type_object(), &folder);
 681   if(!retval )
 682     return NULL;
 683
 684   folder_item_update_freeze();
 685
 686   if(!get_message_list_for_move_or_copy(messagelist, folder, &list))
 687     goto err;
 688
 689   if(move)
 690     procmsg_move_messages(list);
 691   else
 692     procmsg_copy_messages(list);
 693
 694   folder_item_update_thaw();
 695   g_slist_free(list);
 696   Py_RETURN_NONE;
 697
 698 err:
 699   folder_item_update_thaw();
 700   g_slist_free(list);
 701   return NULL;
 702 }
 703
 704 static PyObject* move_messages(PyObject *self, PyObject *args)
 705 {
 706   return move_or_copy_messages(self, args, TRUE);
 707 }
 708
 709
 710 static PyObject* copy_messages(PyObject *self, PyObject *args)
 711 {
 712   return move_or_copy_messages(self, args, FALSE);
 713 }
 714
 715 static PyObject* get_current_account(PyObject *self, PyObject *args)
 716 {
 717   PrefsAccount *account;
 718   account = account_get_cur_account();
 719   if(account) {
 720     return clawsmail_account_new(account);
 721   }
 722   else
 723     Py_RETURN_NONE;
 724 }
 725
 726 static PyObject* get_default_account(PyObject *self, PyObject *args)
 727 {
 728   PrefsAccount *account;
 729   account = account_get_default();
 730   if(account) {
 731     return clawsmail_account_new(account);
 732   }
 733   else
 734     Py_RETURN_NONE;
 735 }
 736
 737
 738 static PyMethodDef ClawsMailMethods[] = {
 739     /* public */
 740     {"get_mainwindow_action_group",  get_mainwindow_action_group, METH_NOARGS,
 741      "get_mainwindow_action_group() - get action group of main window menu\n"
 742      "\n"
 743      "Returns the gtk.ActionGroup for the main window."},
 744
 745     {"get_mainwindow_ui_manager",  get_mainwindow_ui_manager, METH_NOARGS,
 746      "get_mainwindow_ui_manager() - get ui manager of main window\n"
 747      "\n"
 748      "Returns the gtk.UIManager for the main window."},
 749
 750     {"get_folder_tree",  get_folder_tree, METH_VARARGS,
 751      "get_folder_tree([root]) - get a folder tree\n"
 752      "\n"
 753      "Without arguments, get a list of folder trees for all mailboxes.\n"
 754      "\n"
 755      "If the optional root argument is a clawsmail.Folder, the function\n"
 756      "returns a tree of subfolders with the given folder as root element.\n"
 757      "\n"
 758      "If the optional root argument is a clawsmail.Mailbox, the function\n"
 759      "returns a tree of folders with the given mailbox as root element.\n"
 760      "\n"
 761      "If the optional root argument is a string, it is supposed to be a\n"
 762      "mailbox name. The function then returns a tree of folders of that mailbox.\n"
 763      "\n"
 764      "In any case, a tree consists of elements of the type clawsmail.Node."},
 765
 766     {"get_folderview_selected_folder",  get_folderview_selected_folder, METH_NOARGS,
 767      "get_folderview_selected_folder() - get selected folder in folderview\n"
 768      "\n"
 769      "Returns the currently selected folder as a clawsmail.Folder or None if no folder is selected."},
 770     {"folderview_select_folder",  folderview_select_row, METH_VARARGS,
 771      "folderview_select_folder(folder) - select folder in folderview\n"
 772      "\n"
 773      "Takes an argument of type clawsmail.Folder, and selects the corresponding folder.\n"
 774      "\n"
 775      "DEPRECATED: Use folderview_select() instead."},
 776
 777     {"get_folderview_selected_mailbox",  get_folderview_selected_mailbox, METH_NOARGS,
 778      "get_folderview_selected_mailbox() - get selected mailbox in folderview\n"
 779      "\n"
 780      "Returns the currently selected mailbox as a clawsmail.Mailbox or None if no mailbox is selected."},
 781
 782      {"folderview_select",  folderview_select_row, METH_VARARGS,
 783       "folderview_select(arg) - select folder or a mailbox in folderview\n"
 784       "\n"
 785       "Takes an argument of type clawsmail.Folder or clawsmail.Mailbox, and selects the corresponding\n"
 786       "row in the folder view."},
 787
 788     {"quicksearch_search", quicksearch_search, METH_VARARGS,
 789      "quicksearch_search(string [, type]) - perform a quicksearch\n"
 790      "\n"
 791      "Perform a quicksearch of the given string. The optional type argument can be\n"
 792      "one of clawsmail.QUICK_SEARCH_SUBJECT, clawsmail.QUICK_SEARCH_FROM, clawsmail.QUICK_SEARCH_TO,\n"
 793      "clawsmail.QUICK_SEARCH_EXTENDED, clawsmail.QUICK_SEARCH_MIXED, or clawsmail.QUICK_SEARCH_TAG.\n"
 794      "If it is omitted, the current selection is used. The string argument has to be a valid search\n"
 795      "string corresponding to the type."},
 796
 797     {"quicksearch_clear", quicksearch_clear, METH_NOARGS,
 798      "quicksearch_clear() - clear the quicksearch"},
 799
 800     {"get_summaryview_selected_message_list", get_summaryview_selected_message_list, METH_NOARGS,
 801      "get_summaryview_selected_message_list() - get selected message list\n"
 802      "\n"
 803      "Get a list of clawsmail.MessageInfo objects of the current selection."},
 804
 805     {"summaryview_select_messages", summaryview_select_messages, METH_VARARGS,
 806      "summaryview_select_messages(message_list) - select a list of messages in the summary view\n"
 807      "\n"
 808      "Select a list of clawsmail.MessageInfo objects in the summary view."},
 809
 810     {"is_exiting", is_exiting, METH_NOARGS,
 811      "is_exiting() - test whether Claws Mail is currently exiting\n"
 812      "\n"
 813      "Returns True if Claws Mail is currently exiting. The most common usage for this is to skip\n"
 814      "unnecessary cleanup tasks in a shutdown script when Claws Mail is exiting anyways. If the Python\n"
 815      "plugin is explicitly unloaded, the shutdown script will still be called, but this function will\n"
 816      "return False."},
 817
 818     {"move_messages", move_messages, METH_VARARGS,
 819      "move_messages(message_list, target_folder) - move a list of messages to a target folder\n"
 820      "\n"
 821      "Move a list of clawsmail.MessageInfo objects to a target folder.\n"
 822      "The target_folder argument has to be a clawsmail.Folder object."},
 823
 824     {"copy_messages", copy_messages, METH_VARARGS,
 825      "copy_messages(message_list, target_folder) - copy a list of messages to a target folder\n"
 826      "\n"
 827      "Copy a list of clawsmail.MessageInfo objects to a target folder.\n"
 828      "The target_folder argument has to be a clawsmail.Folder object."},
 829
 830     {"get_tags", get_tags, METH_NOARGS,
 831      "get_tags() - get a tuple of all tags that Claws Mail knows about\n"
 832      "\n"
 833      "Get a tuple of strings representing all tags that are defined in Claws Mail."},
 834
 835     {"make_sure_tag_exists", make_sure_tag_exists, METH_VARARGS,
 836      "make_sure_tag_exists(tag) - make sure that the specified tag exists\n"
 837      "\n"
 838      "This function creates the given tag if it does not exist yet.\n"
 839      "It is not an error if the tag already exists. In this case, this function does nothing.\n"
 840      "However, if a reserved tag name is chosen, a ValueError exception is raised."},
 841
 842     {"delete_tag", delete_tag, METH_VARARGS,
 843      "delete_tag(tag) - delete a tag\n"
 844      "\n"
 845      "This function deletes an existing tag.\n"
 846      "Raises a KeyError exception if the tag does not exist."},
 847
 848     {"rename_tag", rename_tag, METH_VARARGS,
 849      "rename_tag(old_tag, new_tag) - rename tag old_tag to new_tag\n"
 850      "\n"
 851      "This function renames an existing tag.\n"
 852      "Raises a KeyError exception if the tag does not exist.\n"
 853      "Raises a ValueError exception if the old or new tag name is a reserved name."},
 854
 855      {"get_accounts", get_accounts, METH_NOARGS,
 856       "get_accounts() - get a tuple of all accounts that Claws Mail knows about\n"
 857       "\n"
 858       "Get a tuple of Account objects representing all accounts that are defined in Claws Mail."},
 859
 860       {"get_current_account", get_current_account, METH_NOARGS,
 861        "get_current_account() - get the current account\n"
 862        "\n"
 863        "Return the object representing the currently selected account."},
 864
 865      {"get_default_account", get_default_account, METH_NOARGS,
 866       "get_default_account() - get the default account\n"
 867       "\n"
 868       "Return the object representing the default account."},
 869
 870      {"get_mailboxes", get_mailboxes, METH_NOARGS,
 871       "get_mailboxes() - get a tuple of all mailboxes that Claws Mail knows about\n"
 872       "\n"
 873       "Get a tuple of Mailbox objects representing all mailboxes that are defined in Claws Mail."},
 874
 875      /* private */
 876     {"__gobj", private_wrap_gobj, METH_VARARGS,
 877      "__gobj(ptr) - transforms a C GObject pointer into a PyGObject\n"
 878      "\n"
 879      "For internal usage only."},
 880
 881     {NULL, NULL, 0, NULL}
 882 };
 883
 884 static gboolean add_miscstuff(PyObject *module)
 885 {
 886   gboolean retval;
 887   PyObject *dict;
 888   PyObject *res;
 889   const char *cmd =
 890       "QUICK_SEARCH_SUBJECT = 0\n"
 891       "QUICK_SEARCH_FROM = 1\n"
 892       "QUICK_SEARCH_TO = 2\n"
 893       "QUICK_SEARCH_EXTENDED = 3\n"
 894       "QUICK_SEARCH_MIXED = 4\n"
 895       "QUICK_SEARCH_TAG = 5\n"
 896       "\n";
 897   dict = PyModule_GetDict(module);
 898   res = PyRun_String(cmd, Py_file_input, dict, dict);
 899   retval = (res != NULL);
 900   Py_XDECREF(res);
 901   return retval;
 902 }
 903
 904
 905 PyMODINIT_FUNC initclawsmail(void)
 906 {
 907   gboolean ok = TRUE;
 908
 909   /* create module */
 910   cm_module = Py_InitModule3("clawsmail", ClawsMailMethods,
 911       "This module can be used to access some of Claws Mail's data structures\n"
 912       "in order to extend or modify the user interface or automate repetitive tasks.\n"
 913       "\n"
 914       "Whenever possible, the interface works with standard GTK+ widgets\n"
 915       "via the PyGTK bindings, so you can refer to the GTK+ / PyGTK documentation\n"
 916       "to find out about all possible options.\n"
 917       "\n"
 918       "The interface to Claws Mail in this module is extended on a 'as-needed' basis.\n"
 919       "If you're missing something specific, try contacting the author.");
 920
 921   /* add module member "compose_window" set to None */
 922   Py_INCREF(Py_None);
 923   PyModule_AddObject(cm_module, "compose_window", Py_None);
 924
 925   /* initialize classes */
 926   ok = ok && cmpy_add_node(cm_module);
 927   ok = ok && cmpy_add_composewindow(cm_module);
 928   ok = ok && cmpy_add_folder(cm_module);
 929   ok = ok && cmpy_add_messageinfo(cm_module);
 930   ok = ok && cmpy_add_account(cm_module);
 931   ok = ok && cmpy_add_folderproperties(cm_module);
 932   ok = ok && cmpy_add_mailbox(cm_module);
 933
 934   /* initialize misc things */
 935   if(ok)
 936     add_miscstuff(cm_module);
 937 }
 938
 939
 940 void put_composewindow_into_module(Compose *compose)
 941 {
 942   PyObject *pycompose;
 943
 944   pycompose = clawsmail_compose_new(cm_module, compose);
 945   PyObject_SetAttrString(cm_module, "compose_window", pycompose);
 946   Py_DECREF(pycompose);
 947 }