static gboolean
indicator_load(PurplePlugin *plugin) {
  indicator_docklet_init(plugin, &ui_ops);

  AppIndicator *indicator =
    app_indicator_new_with_path("pidgin", PIDGIN_STOCK_TRAY_AVAILABLE,
                                APP_INDICATOR_CATEGORY_APPLICATION_STATUS,
                                DATADIR G_DIR_SEPARATOR_S "pixmaps" G_DIR_SEPARATOR_S "pidgin" G_DIR_SEPARATOR_S "tray");

  sIndicator = indicator;

  app_indicator_set_status(indicator, APP_INDICATOR_STATUS_ACTIVE);
  indicator_update_icon(purple_savedstatus_get_type(purple_savedstatus_get_current()),
                        FALSE, FALSE);

  void *plugins_handle = purple_plugins_get_handle();
  purple_signal_connect(plugins_handle, "plugin-load", plugin->handle,
                        PURPLE_CALLBACK(indicator_build_menu), indicator);
  purple_signal_connect(plugins_handle, "plugin-unload", plugin->handle,
                        PURPLE_CALLBACK(indicator_build_menu), indicator);
  indicator_build_menu(NULL, indicator);

  plugin->extra = indicator;

  pidgin_blist_visibility_manager_add();

  return TRUE;
}
示例#2
0
static gboolean
plugin_load(PurplePlugin *plugin, GError **error)
{
	GList *convs = purple_conversations_get_all();
	PurpleSavedStatus *saved_status;
	void *conv_handle = purple_conversations_get_handle();
	void *gtk_conv_handle = pidgin_conversations_get_handle();
	void *savedstat_handle = purple_savedstatuses_get_handle();

	purple_prefs_add_none("/plugins/gtk");
	purple_prefs_add_none("/plugins/gtk/unity");
	purple_prefs_add_int("/plugins/gtk/unity/launcher_count", LAUNCHER_COUNT_SOURCES);
	purple_prefs_add_int("/plugins/gtk/unity/messaging_menu_text", MESSAGING_MENU_COUNT);
	purple_prefs_add_bool("/plugins/gtk/unity/alert_chat_nick", TRUE);

	alert_chat_nick = purple_prefs_get_bool("/plugins/gtk/unity/alert_chat_nick");

	mmapp = messaging_menu_app_new("pidgin.desktop");
	g_object_ref(mmapp);
	messaging_menu_app_register(mmapp);
	messaging_menu_text = purple_prefs_get_int("/plugins/gtk/unity/messaging_menu_text");

	g_signal_connect(mmapp, "activate-source",
			G_CALLBACK(message_source_activated), NULL);
	g_signal_connect(mmapp, "status-changed",
			G_CALLBACK(messaging_menu_status_changed), NULL);

	saved_status = purple_savedstatus_get_current();
	status_changed_cb(saved_status);

	purple_signal_connect(savedstat_handle, "savedstatus-changed", plugin,
			PURPLE_CALLBACK(status_changed_cb), NULL);

	launcher = unity_launcher_entry_get_for_desktop_id("pidgin.desktop");
	g_object_ref(launcher);
	launcher_count = purple_prefs_get_int("/plugins/gtk/unity/launcher_count");

	purple_signal_connect(gtk_conv_handle, "displayed-im-msg", plugin,
			PURPLE_CALLBACK(message_displayed_cb), NULL);
	purple_signal_connect(gtk_conv_handle, "displayed-chat-msg", plugin,
			PURPLE_CALLBACK(message_displayed_cb), NULL);
	purple_signal_connect(conv_handle, "sent-im-msg", plugin,
			PURPLE_CALLBACK(im_sent_im), NULL);
	purple_signal_connect(conv_handle, "sent-chat-msg", plugin,
			PURPLE_CALLBACK(chat_sent_im), NULL);
	purple_signal_connect(conv_handle, "conversation-created", plugin,
			PURPLE_CALLBACK(conv_created), NULL);
	purple_signal_connect(conv_handle, "deleting-conversation", plugin,
			PURPLE_CALLBACK(deleting_conv), NULL);

	while (convs) {
		PurpleConversation *conv = (PurpleConversation *)convs->data;
		attach_signals(conv);
		convs = convs->next;
	}

	return TRUE;
}
示例#3
0
//gets the text of whatever the user sets the status to. (not necessarily what status is on the server)
//client_text and server_text are freed if it returns false
static gboolean getStatusText(char** client_text, char** server_text, PurpleAccount *account, const char** sid)
{
	PurpleStatus* status;
	PurpleSavedStatus* savedStatus;
	PurpleSavedStatusSub* substat;
	const char* statusMessage;

	status = purple_account_get_active_status(account);
	if (status == NULL)
       	{
		purple_debug_fatal("MusicInfo", "Account with NULL status\n");
		return FALSE;
	}

	*sid = purple_status_get_id(status);
	statusMessage = purple_status_get_attr_string(status, "message");
	if(statusMessage != NULL)
	{
		*server_text = g_strdup(statusMessage);
	}
	else
	{
		*server_text = g_strdup("\0");
	}


	savedStatus = purple_savedstatus_get_current();
	if (savedStatus == NULL) 
	{
		purple_debug_fatal("MusicInfo", "Account with NULL saved status\n");
		g_free(*server_text);
		return FALSE;
	}
	
	statusMessage = NULL;
	if(purple_savedstatus_has_substatuses(savedStatus))
	{
		substat = purple_savedstatus_get_substatus(savedStatus, account);
		if(substat != NULL)
			statusMessage = purple_savedstatus_substatus_get_message(substat);
	}
	
	if(statusMessage == NULL)
	{
		statusMessage = purple_savedstatus_get_message(savedStatus);
	}
		
	if(statusMessage == NULL)
	{
		g_free(*server_text);
		return FALSE;
	}
	
	*client_text = g_strdup(statusMessage);
	return TRUE;
}
示例#4
0
static gboolean
set_status (PurpleAccount *acnt, const char *loc)
{
   // discover the pidgin saved status in use for this account
   const char *savedmessage = "";
   {
      PurpleSavedStatus *savedstatus = purple_savedstatus_get_current();
      if (savedstatus)
      {
         PurpleSavedStatusSub *savedsubstatus = purple_savedstatus_get_substatus(savedstatus, acnt);
         if (savedsubstatus)
         {
            // use account-specific saved status
            savedmessage = purple_savedstatus_substatus_get_message(savedsubstatus);
         }
         else
         {
            // don't have an account-specific saved status, use the general one
            savedmessage = purple_savedstatus_get_message(savedstatus);
         }
      }
   }

   /* generate status */
   char *msg;
   if (savedmessage) {
      msg = (char *)malloc(strlen(savedmessage)+strlen(loc)+1);
      strcpy(msg, loc);
      strcat(msg, savedmessage);
   }
   else msg = loc;

	PurpleStatus *status = purple_account_get_active_status (acnt);
   GList *attrs = NULL;
   attrs = g_list_append(attrs, "message");
   attrs = g_list_append(attrs, (gpointer)msg);
   purple_status_set_active_with_attrs_list(status, TRUE, attrs);
   g_list_free(attrs);
   trace("setup the account(%s) status: %s", acnt->username, msg);

   if (savedmessage) {
      free(msg);
   }

   return TRUE;
}
static void received_im_msg_cb(PurpleAccount *account, char *who, char *buffer,
    PurpleConversation *conv, PurpleMessageFlags flags, void *data) {
    // A workaround to avoid skipping of the first message as a result on NULL-conv:
    if (conv == NULL) conv = purple_conversation_new(PURPLE_CONV_TYPE_IM,
        account, who); 
    PurpleBuddy *buddy = purple_find_buddy(account, who);
    PurplePresence *presence = purple_buddy_get_presence(buddy);
    msg_metadata_t msg;

    //Get message
    msg.text = purple_markup_strip_html(buffer);
    msg.remote_username = who;

    //LOCAL USER:
    msg.local_alias = purple_account_get_alias(account);
    msg.local_username = (char *) purple_account_get_name_for_display(account);

    //REMOTE USER (Buddy):
    //Get buddy alias
    msg.remote_alias = purple_buddy_get_alias(buddy);
    if(msg.remote_alias == NULL) msg.remote_alias = "";

    //Get buddy group
    PurpleGroup *group = purple_buddy_get_group(buddy);
    //return empty string if not in group
    msg.remote_from_group = group != NULL ? purple_group_get_name(group) : ""; 

    //Get protocol ID
    msg.protocol_id = purple_account_get_protocol_id(account);
    //trim out PROTOCOL_PREFIX (eg.: "prpl-irc" => "irc")
    if(!strncmp(msg.protocol_id,PROTOCOL_PREFIX,strlen(PROTOCOL_PREFIX))) 
        msg.protocol_id += strlen(PROTOCOL_PREFIX); 

    //Get status
    PurpleStatus *status = purple_account_get_active_status(account);
    PurpleStatusType *type = purple_status_get_type(status);
    //remote
    PurpleStatus *r_status = purple_presence_get_active_status(presence);
    PurpleStatusType *r_status_type =	purple_status_get_type(r_status);

    //Get status id
    msg.local_status_id = NULL;
    msg.local_status_id = purple_primitive_get_id_from_type(
        purple_status_type_get_primitive(type));
    //remote
    msg.remote_status_id = NULL;
    msg.remote_status_id = purple_primitive_get_id_from_type(
        purple_status_type_get_primitive(r_status_type));

    //Get status message
    msg.local_status_msg = NULL;
    if (purple_status_type_get_attr(type, "message") != NULL) {
        msg.local_status_msg = purple_status_get_attr_string(status, "message");
    } else {
        PurpleSavedStatus *savedstatus = purple_savedstatus_get_current();
        if(savedstatus)
            msg.local_status_msg = purple_savedstatus_get_message(savedstatus);
    }
    //remote
    msg.remote_status_msg = NULL;
    if (purple_status_type_get_attr(r_status_type, "message") != NULL) {
        msg.remote_status_msg = purple_status_get_attr_string(r_status, "message");
    } else {
        msg.remote_status_msg = "";
    }

    run_lua(conv, msg);
}
/////////////////////////////////////////////////////////////////////////////
// The window procedure.  It handles WTS_SESSION_LOCK and WTS_SESSION_UNLOCK
//  messages sent to the LNR window.
/////////////////////////////////////////////////////////////////////////////
static LRESULT CALLBACK LnrWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    GList *accts, *iter;
    PurpleAccount *acct = NULL;
    PurpleStatusType *status_type = NULL;
    PurpleSavedStatus *saved_status = NULL;

    switch(uMsg)
    {
    case WM_WTSSESSION_CHANGE:
        switch(wParam)
        {
        case WTS_SESSION_LOCK:
        case WTS_REMOTE_DISCONNECT:

            saved_status = purple_savedstatus_new(NULL, purple_prefs_get_int(LNR_PREF_STATUS));
            purple_savedstatus_set_message(saved_status, purple_prefs_get_string(LNR_PREF_MESSAGE));

            iter = accts = purple_accounts_get_all_active();
            for(; iter != NULL; iter = iter->next)
            {
                acct = (PurpleAccount*)iter->data;
                if(lnr_should_change_message(acct))
                {
                    status_type = purple_account_get_status_type_with_primitive(acct, purple_prefs_get_int(LNR_PREF_STATUS));
                    if(status_type != NULL)
                    {
                        // Set the substatus for this account
                        purple_savedstatus_set_substatus(saved_status, acct, status_type, purple_prefs_get_string(LNR_PREF_MESSAGE));
                        lnr_accts = g_list_append(lnr_accts, acct);
                    }
                }
            }

            if(g_list_length(lnr_accts))
            {
                lnr_reactivate_status = purple_savedstatus_get_current();
                purple_savedstatus_activate(saved_status);
            }
            else
            {
                lnr_reactivate_status = NULL;
                g_list_free(lnr_accts);
                lnr_accts = NULL;
            }

            g_list_free(accts);
            accts = NULL;

            break;
            
        case WTS_SESSION_UNLOCK:
        case WTS_REMOTE_CONNECT:

            if(lnr_accts != NULL)
            {
                if (lnr_reactivate_status != NULL)
                {
                    purple_savedstatus_activate(lnr_reactivate_status);
                }
                else
                {
                    saved_status = purple_savedstatus_new(NULL, PURPLE_STATUS_AVAILABLE);
                    purple_savedstatus_set_message(saved_status, "");

                    for(iter = lnr_accts; iter != NULL; iter = iter->next)
                    {
                        acct = (PurpleAccount*)iter->data;
                        // Set the status up with a generic "Available" message for each account
                        status_type = purple_account_get_status_type_with_primitive(acct, PURPLE_STATUS_AVAILABLE);
                        if(status_type != NULL)
                        {
                            purple_savedstatus_set_substatus(saved_status, acct, status_type, "");
                        }
                    }

                    purple_savedstatus_activate(saved_status);
                }

                lnr_reactivate_status = NULL;
                g_list_free(lnr_accts);
                lnr_accts = NULL;
            }
            break;
        }
        break;
    }

    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}