नॉटिलस सी एक्सटेंशन कैसे बनाएं

Question

मैं सी में नॉटिलस एक्सटेंशन बनाने की कोशिश कर रहा हूं, लेकिन केवल पाइथन उदाहरण हैं और मदद करता है।

लगभग कोई दस्तावेज और शाब्दिक रूप से कोई उदाहरण नहीं है, लेकिन केवल कुछ पूर्ण एक्सटेंशन जो शुरुआती के लिए समझने में लंबे और कठिन हैं।

मुझे केवल एक साधारण नमूना कोड चाहिए जो नॉटिलस के सूची दृश्य में एक नया कॉलम बनाता है। इसे कैसे लिखें और संकलित करें।

कोड मैं कोशिश की है है:

#include <libnautilus-extension/nautilus-column-provider.h> 

typedef struct _FooExtension FooExtension; 
typedef struct _FooExtensionClass FooExtensionClass; 

struct _FooExtension 
{ 
    GObject parent_slot; 
}; 

struct _FooExtensionClass 
{ 
    GObjectClass parent_slot; 
}; 

static void foo_extension_class_init (FooExtensionClass *class); 
static void foo_extension_instance_init (FooExtension  *img); 

static void foo_extension_class_init(FooExtensionClass *class) 
{ 
} 

static void foo_extension_instance_init(FooExtension *img) 
{ 
} 

static GType provider_types[1]; 

static GType foo_extension_type; 

static void foo_extension_register_type(GTypeModule *module) 
{ 
    static const GTypeInfo info = { 
       sizeof(FooExtensionClass), 
       (GBaseInitFunc) NULL, 
       (GBaseFinalizeFunc) NULL, 
       (GClassInitFunc) foo_extension_class_init, 
       NULL, 
       NULL, 
       sizeof (FooExtension), 
       0, 
       (GInstanceInitFunc) foo_extension_instance_init, 
       }; 
    foo_extension_type = g_type_module_register_type(module, 
           G_TYPE_OBJECT, 
           "FooExtension", 
           &info, 0); 
     /* ... add interfaces ... */ 
} 

GType foo_extension_get_type(void) 
{ 
    return foo_extension_type; 
} 

static GList *foo_extension_get_columns(NautilusColumnProvider *provider) 
{ 
    NautilusColumn *column; 
    GList *ret; 
    column = nautilus_column_new("FooExtension::foo_data_column", "FooExtension::foo_data", "Foo Data", "Foo Description"); 
/*     _("Foo Data"), 
         _("Information from the Foo Extension"));*/ 
    ret = g_list_append(NULL, column); 
    return ret; 
} 

void nautilus_module_initialize (GTypeModule *module) 
{ 
    foo_extension_register_type(module); 
    provider_types[0] = foo_extension_get_type(); 
} 

void nautilus_module_shutdown(void) 
{ 
    /* Any module-specific shutdown */ 
} 

void nautilus_module_list_types (const GType **types, int *num_types) 
{ 
    *types = provider_types; 
    *num_types = G_N_ELEMENTS (provider_types); 
} 

और मैं के साथ बनाया है:

gcc-c foo_extension.c -o foo_extension.o -fPIC $(pkg-config libnautilus-extension --libs --cflags) 
gcc -shared foo_extension.o -o foo_extension.so $(pkg-config libnautilus-extension --libs --cflags) 

और मैं इसे /usr/lib/nautilus/extensions-2.0/ में नकल, तो मैं nautilus -q की कोशिश की लेकिन यह नहीं है काम।

Answer 1

आप Nautilus Extension's wiki में the copy in archive.org से प्रलेखन को भी पुनर्प्राप्त कर सकते हैं। Archive.org में कॉपी में सी

संपादित करें: मैंने एक पूर्ण कार्य उदाहरण जोड़ा, साथ ही साथ आपके कोड में लापता हिस्सों की व्याख्या भी शामिल की।

1. इंटरफेस जोड़ें:

   आप दो बातें याद कर रहे हैं। कॉलम प्रदाता के लिए foo_extension_column_provider_iface_init होगा, और वहां आपको लिंक को आपके कार्यान्वयन के साथ अपेक्षित इंटरफेस को जोड़ने की आवश्यकता है। इस विशेष मामले में get_columns।

2. पिछले एक के साथ, आपको केवल एक कॉलम मिलेगा लेकिन प्रत्येक फ़ाइल के लिए अज्ञात मान के साथ। इसलिए, आपको InfoProvider का भी उपयोग करना होगा। विशेष रूप से, इंटरफ़ेस update_file_info। उस इंटरफ़ेस में आप प्रत्येक कॉलम के साथ nautilus_file_info_add_string_attribute के माध्यम से प्रत्येक कॉलम के साथ विशेषता को जोड़ सकते हैं।

नीचे आपके पास एक कामकाजी उदाहरण है। सावधान रहें NautilusFileInfoProvider नॉटिलस 'एसिंक्रोनस आईओ सिस्टम का हिस्सा है। इसलिए, यदि संचालन धीमा है, तो आप नॉटिलस को अवरुद्ध कर देंगे। नीचे दिए गए उदाहरण में मैंने प्रति फ़ाइल एक निश्चित स्ट्रिंग सेट की है ("Foo")। हालांकि, अगर आपको अन्य जानकारी एकत्र करने की आवश्यकता है, तो आपको तर्क भी लागू करना चाहिए update_complete और संभाल लें, और cancel_update इंटरफ़ेस। चेक documentation whose copy is available in archive.org

#include <libnautilus-extension/nautilus-column-provider.h> 
#include <libnautilus-extension/nautilus-info-provider.h> 

typedef struct _FooExtension FooExtension; 
typedef struct _FooExtensionClass FooExtensionClass; 

typedef struct { 
    GClosure *update_complete; 
    NautilusInfoProvider *provider; 
    NautilusFileInfo *file; 
    int operation_handle; 
    gboolean cancelled; 
} UpdateHandle; 

struct _FooExtension 
{ 
    GObject parent_slot; 
}; 

struct _FooExtensionClass 
{ 
    GObjectClass parent_slot; 
}; 

static void foo_extension_class_init (FooExtensionClass *class); 
static void foo_extension_instance_init (FooExtension  *img); 
static GList *foo_extension_get_columns (NautilusColumnProvider *provider); 
static NautilusOperationResult foo_extension_update_file_info (
             NautilusInfoProvider *provider, 
             NautilusFileInfo *file, 
             GClosure *update_complete, 
             NautilusOperationHandle **handle); 

/* Interfaces */ 
static void 
foo_extension_column_provider_iface_init (NautilusColumnProviderIface *iface) { 
    iface->get_columns = foo_extension_get_columns; 
    return; 
} 

static void 
foo_extension_info_provider_iface_init (NautilusInfoProviderIface *iface) { 
    iface->update_file_info = foo_extension_update_file_info; 
    return; 
} 

/* Extension */ 
static void foo_extension_class_init(FooExtensionClass *class) 
{ 
} 

static void foo_extension_instance_init(FooExtension *img) 
{ 
} 

static GType provider_types[1]; 

static GType foo_extension_type; 

static void foo_extension_register_type(GTypeModule *module) 
{ 
    static const GTypeInfo info = { 
       sizeof(FooExtensionClass), 
       (GBaseInitFunc) NULL, 
       (GBaseFinalizeFunc) NULL, 
       (GClassInitFunc) foo_extension_class_init, 
       NULL, 
       NULL, 
       sizeof (FooExtension), 
       0, 
       (GInstanceInitFunc) foo_extension_instance_init, 
       }; 

    static const GInterfaceInfo column_provider_iface_info = { 
     (GInterfaceInitFunc) foo_extension_column_provider_iface_init, 
     NULL, 
     NULL 
    }; 

    static const GInterfaceInfo info_provider_iface_info = { 
     (GInterfaceInitFunc) foo_extension_info_provider_iface_init, 
     NULL, 
     NULL 
    }; 

    foo_extension_type = g_type_module_register_type(module, 
           G_TYPE_OBJECT, 
           "FooExtension", 
           &info, 0); 

    /* ... add interfaces ... */ 
    g_type_module_add_interface (module, 
           foo_extension_type, 
           NAUTILUS_TYPE_COLUMN_PROVIDER, 
           &column_provider_iface_info); 

    g_type_module_add_interface (module, 
           foo_extension_type, 
           NAUTILUS_TYPE_INFO_PROVIDER, 
           &info_provider_iface_info); 
} 

GType foo_extension_get_type(void) 
{ 
    return foo_extension_type; 
} 

/* Column interfaces */ 
static GList *foo_extension_get_columns(NautilusColumnProvider *provider) 
{ 
    NautilusColumn *column; 
    GList *ret; 
    column = nautilus_column_new ("FooExtension::foo_data_column", 
            "FooExtension::foo_data", 
            "Foo Data", 
            "Foo Description"); 
    ret = g_list_append(NULL, column); 

    return ret; 
} 

/* Info interfaces */ 
static NautilusOperationResult 
foo_extension_update_file_info (NautilusInfoProvider *provider, 
           NautilusFileInfo *file, 
           GClosure *update_complete, 
           NautilusOperationHandle **handle) 
{ 
    char *data; 

    /* Check if we've previously cached the file info */ 
    data = g_object_get_data (G_OBJECT (file), "foo_extension_data"); 

    /* get and provide the information associated with the column. 
     If the operation is not fast enough, we should use the arguments 
     update_complete and handle for asyncrhnous operation. */ 
    if (!data) { 
     data = g_strdup ("Foo"); 
    } 

    nautilus_file_info_add_string_attribute (file, 
          "FooExtension::foo_data", 
          data); 
    return NAUTILUS_OPERATION_COMPLETE; 
} 

/* Extension initialization */ 
void nautilus_module_initialize (GTypeModule *module) 
{ 
    foo_extension_register_type(module); 
    provider_types[0] = foo_extension_get_type(); 
} 

void nautilus_module_shutdown(void) 
{ 
    /* Any module-specific shutdown */ 
} 

void nautilus_module_list_types (const GType **types, int *num_types) 
{ 
    *types = provider_types; 
    *num_types = G_N_ELEMENTS (provider_types); 
} 

यह संकलन के लिए: एक्सटेंशन के परीक्षण के लिए

$ gcc -c foo-extension.c -o foo-extension.o -fPIC $(pkg-config libnautilus-extension --cflags) 
$ gcc -shared foo-extension.o -o foo-extension.so $(pkg-config libnautilus-extension --libs) 

, पहले आप नॉटिलस के किसी भी चल रहा है उदाहरण के बंद करो और फिर से लांच नॉटिलस की जरूरत है।यही कारण है:

$ nautilus -q 
$ nautilus 

नोट विकल्प -q आप का इस्तेमाल किया है, जो छोड़ने के लिए बिना है।

आप अगर नॉटिलस आपका एक्सटेंशन लोड कर रहा है जांच करना चाहते हैं, तो आप इस प्रकार strace उपयोग कर सकते हैं:

$ strace -e trace=open nautilus 

और देखो क्या पुस्तकालयों और फ़ाइलों नॉटिलस लोड कर रहा है/उद्घाटन।

अपने एक्सटेंशन में काम करते समय, एक्सटेंशन फ़ाइल को [libdir] /nautilus/extensions-3.0 में कॉपी करने के बजाय, आप अपनी कार्यशील निर्देशिका में एक सिम्लिंक बना सकते हैं। यदि आप नॉटिलस 2.x का उपयोग कर रहे हैं, तो इसके बजाय [libdir] /nautilus/extensions-2.0 का उपयोग करें।