Beispiel #1
0
static void
manager_send_filter(StackManager *manager)
{
    DDMDataQuery *query;
    char *filter_string = make_filter_string(manager);

    query = ddm_data_model_update(manager->model,
                                  "http://mugshot.org/p/blocks#setStackFilter", NULL,
                                  "filter", filter_string,
                                  NULL);
    
    ddm_data_query_set_error_handler(query, on_send_filter_error, manager);

    g_free(filter_string);
    
}
Beispiel #2
0
static void
manager_get_old_blocks(StackManager *manager)
{
    DDMDataQuery *query;
    char *filter_string = make_filter_string(manager);
        
    query = ddm_data_model_query(manager->model,
                                 "http://mugshot.org/p/blocks#getOldBlocks", "+",
                                 "filter", filter_string,
                                  NULL);
    
    ddm_data_query_set_multi_handler(query, on_get_old_blocks_success, manager);
    ddm_data_query_set_error_handler(query, on_get_old_blocks_error, manager);

    g_free(filter_string);
}
int
do_lvm_set_filter (char *const *devices)
{
  CLEANUP_FREE char *filter = make_filter_string (devices);
  if (filter == NULL)
    return -1;

  if (deactivate () == -1)
    return -1;

  int r = set_filter (filter);
  if (r == -1)
    return -1;

  if (rescan () == -1)
    return -1;

  return reactivate ();
}
Beispiel #4
0
int file_open_dialog(Value *vret, const char *title, RefArray *filter, WndHandle parent, int type)
{
    enum {
        RETBUF_MAX = 32 * 1024,
    };
    int ret = FALSE;
    wchar_t *title_p = cstr_to_utf16(title, -1);
    wchar_t *filter_p = NULL;
    wchar_t *wbuf = malloc(RETBUF_MAX);
    int offset = 0;

    memset(wbuf, 0, RETBUF_MAX);

    if (type == FILEOPEN_DIR) {
        BROWSEINFOW bi;
        LPMALLOC pm = NULL;

        if (SHGetMalloc(&pm) != E_FAIL) {
            ITEMIDLIST *id;

            memset(&bi, 0, sizeof(bi));
            bi.hwndOwner = parent;
            bi.ulFlags = BIF_RETURNONLYFSDIRS;
            bi.lpszTitle = title_p;

            id = SHBrowseForFolderW(&bi);
            if (id != NULL){
                SHGetPathFromIDListW(id, wbuf);
                pm->lpVtbl->Free(pm, id);
                pm->lpVtbl->Release(pm);
                ret = TRUE;
            }
        }
    } else {
        OPENFILENAMEW of;
        memset(&of, 0, sizeof(of));
        of.hwndOwner = parent;
        of.lpstrFile = wbuf;
        of.nMaxFile = RETBUF_MAX - 16;
        of.hInstance = GetModuleHandle(NULL);
        of.lStructSize = sizeof(of);
        of.Flags = OFN_NOCHANGEDIR | OFN_CREATEPROMPT;
        of.lpstrTitle = title_p;

        if (filter != NULL) {
            filter_p = make_filter_string(filter);
            of.lpstrFilter = filter_p;
        }

        switch (type) {
        case FILEOPEN_OPEN:
            of.Flags |= OFN_HIDEREADONLY;
            ret = (GetOpenFileNameW(&of) != 0);
            break;
        case FILEOPEN_OPEN_MULTI:
            of.Flags |= OFN_HIDEREADONLY | OFN_ALLOWMULTISELECT | OFN_EXPLORER;
            ret = (GetOpenFileNameW(&of) != 0);
            offset = of.nFileOffset;
            break;
        case FILEOPEN_SAVE:
            of.Flags |= OFN_OVERWRITEPROMPT | OFN_EXTENSIONDIFFERENT | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
            ret = (GetSaveFileNameW(&of) != 0);
            break;
        }
    }

    if (ret) {
        if (type == FILEOPEN_OPEN_MULTI) {
            RefArray *aret = fs->refarray_new(0);
            wchar_t *p = wbuf;
            int dlen = wcslen(p);
            *vret = vp_Value(aret);

            if (offset <= dlen) {
                array_add_file(aret, p);
            } else {
                wchar_t *dir_part = p;
                p = &p[offset];

                while (*p != L'\0'){
                    wchar_t *filename = concat_filename(dir_part, p);
                    array_add_file(aret, filename);
                    free(filename);
                    p += wcslen(p) + 1;
                }
            }
        } else {
            *vret = utf16_file_Value(wbuf);
        }
    }

    free(title_p);
    free(wbuf);
    free(filter_p);

    return ret;
}